Subscribe:

Ads 468x60px

Saturday, July 21, 2012

Camera calibration using OpenCV

Hi Guys

      I am giving the procedures for camera calibration using OpenCV

What is camera calibration

Camera resectioning is the process of finding the true parameters of the camera that produced a given photograph or video. Usually, the camera parameters are represented in a 3 × 4 matrix called the camera matrix.
This process is often called camera calibration, but "camera calibration" can also mean photometric camera calibration.

For more details refer Wiki Link

Camera calibration using OpenCV

1)Install and configure OpenCV in Visual studio 2008 .The tutorials are available in following link


2)Camera calibration program download from here




 #include <iostream>  
 #include <sstream>  
 #include <time.h>  
   
 #include <opencv2/core/core.hpp>  
 #include <opencv2/imgproc/imgproc.hpp>  
 #include <opencv2/calib3d/calib3d.hpp>  
 #include <opencv2/highgui/highgui.hpp>  
   
 using namespace cv;  
 using namespace std;  
   
 void help()  
 {  
   cout << "This is a camera calibration sample." << endl   
      << "Usage: calibration configurationFile" << endl  
      << "Near the sample file you'll find the configuration file, which has detailed help of "  
        "how to edit it. It may be any OpenCV supported file format XML/YAML." << endl;  
 }  
 class Settings  
 {  
 public:  
   Settings() : goodInput(false) {}  
   enum Pattern { NOT_EXISTING, CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID };  
   enum InputType {INVALID, CAMERA, VIDEO_FILE, IMAGE_LIST};  
   
   void write(FileStorage& fs) const            //Write serialization for this class  
   {  
     fs << "{" << "BoardSize_Width" << boardSize.width   
          << "BoardSize_Height" << boardSize.height   
          << "Square_Size"     << squareSize  
          << "Calibrate_Pattern" << patternToUse  
          << "Calibrate_NrOfFrameToUse" << nrFrames  
          << "Calibrate_FixAspectRatio" << aspectRatio  
          << "Calibrate_AssumeZeroTangentialDistortion" << calibZeroTangentDist  
          << "Calibrate_FixPrincipalPointAtTheCenter" << calibFixPrincipalPoint  
            
          << "Write_DetectedFeaturePoints" << bwritePoints  
          << "Write_extrinsicParameters"  << bwriteExtrinsics  
          << "Write_outputFileName" << outputFileName  
            
          << "Show_UndistortedImage" << showUndistorsed  
            
          << "Input_FlipAroundHorizontalAxis" << flipVertical  
          << "Input_Delay" << delay  
          << "Input" << input  
       << "}";  
   }  
   void read(const FileNode& node)             //Read serialization for this class  
   {  
     node["BoardSize_Width" ] >> boardSize.width;  
     node["BoardSize_Height"] >> boardSize.height;  
     node["Calibrate_Pattern"] >> patternToUse;  
     node["Square_Size"] >> squareSize;  
     node["Calibrate_NrOfFrameToUse"] >> nrFrames;  
     node["Calibrate_FixAspectRatio"] >> aspectRatio;  
     node["Write_DetectedFeaturePoints"] >> bwritePoints;  
     node["Write_extrinsicParameters"] >> bwriteExtrinsics;  
     node["Write_outputFileName"] >> outputFileName;  
     node["Calibrate_AssumeZeroTangentialDistortion"] >> calibZeroTangentDist;  
     node["Calibrate_FixPrincipalPointAtTheCenter"] >> calibFixPrincipalPoint;  
     node["Input_FlipAroundHorizontalAxis"] >> flipVertical;  
     node["Show_UndistortedImage"] >> showUndistorsed;  
     node["Input"] >> input;  
     node["Input_Delay"] >> delay;  
     interprate();  
   }  
   void interprate()  
   {  
     goodInput = true;   
     if (boardSize.width <= 0 || boardSize.height <= 0)  
     {  
       cerr << "Invalid Board size: " << boardSize.width << " " << boardSize.height << endl;  
       goodInput = false;  
     }  
     if (squareSize <= 10e-6)  
     {  
       cerr << "Invalid square size " << squareSize << endl;  
       goodInput = false;  
     }  
     if (nrFrames <= 0)  
     {  
       cerr << "Invalid number of frames " << nrFrames << endl;  
       goodInput = false;  
     }  
   
     if (input.empty())   // Check for valid input  
         inputType = INVALID;  
     else  
     {  
       if (input[0] >= '0' && input[0] <= '9')  
       {  
         stringstream ss(input);  
         ss >> cameraID;  
         inputType = CAMERA;  
       }  
       else  
       {  
         if (readStringList(input, imageList))  
           {  
             inputType = IMAGE_LIST;  
             nrFrames = (nrFrames < imageList.size()) ? nrFrames : imageList.size();  
           }  
         else  
           inputType = VIDEO_FILE;  
       }  
       if (inputType == CAMERA)  
         inputCapture.open(cameraID);   
       if (inputType == VIDEO_FILE)  
         inputCapture.open(input);  
       if (inputType != IMAGE_LIST && !inputCapture.isOpened())  
           inputType = INVALID;  
     }  
     if (inputType == INVALID)   
     {  
       cerr << " Inexistent input: " << input;  
       goodInput = false;  
     }  
   
     flag = 0;   
     if(calibFixPrincipalPoint) flag |= CV_CALIB_FIX_PRINCIPAL_POINT;  
     if(calibZeroTangentDist)  flag |= CV_CALIB_ZERO_TANGENT_DIST;  
     if(aspectRatio)      flag |= CV_CALIB_FIX_ASPECT_RATIO;  
       
       
     calibrationPattern = NOT_EXISTING;  
     if (!patternToUse.compare("CHESSBOARD")) calibrationPattern = CHESSBOARD;  
     if (!patternToUse.compare("CIRCLES_GRID")) calibrationPattern = CIRCLES_GRID;  
     if (!patternToUse.compare("ASYMMETRIC_CIRCLES_GRID")) calibrationPattern = ASYMMETRIC_CIRCLES_GRID;  
     if (calibrationPattern == NOT_EXISTING)  
       {  
         cerr << " Inexistent camera calibration mode: " << patternToUse << endl;  
         goodInput = false;  
       }  
     atImageList = 0;  
       
   }  
   Mat nextImage()  
   {  
     Mat result;   
     if( inputCapture.isOpened() )  
     {  
       Mat view0;  
       inputCapture >> view0;  
       view0.copyTo(result);  
     }  
     else if( atImageList < (int)imageList.size() )  
       result = imread(imageList[atImageList++], CV_LOAD_IMAGE_COLOR);  
       
     return result;  
   }  
     
   static bool readStringList( const string& filename, vector<string>& l )  
   {  
     l.clear();  
     FileStorage fs(filename, FileStorage::READ);  
     if( !fs.isOpened() )  
       return false;  
     FileNode n = fs.getFirstTopLevelNode();  
     if( n.type() != FileNode::SEQ )  
       return false;  
     FileNodeIterator it = n.begin(), it_end = n.end();  
     for( ; it != it_end; ++it )  
       l.push_back((string)*it);  
     return true;  
   }  
 public:   
   Size boardSize;      // The size of the board -> Number of items by width and height  
   Pattern calibrationPattern;// One of the Chessboard, circles, or asymmetric circle pattern  
   float squareSize;     // The size of a square in your defined unit (point, millimeter,etc).  
   int nrFrames;       // The number of frames to use from the input for calibration  
   float aspectRatio;     // The aspect ratio  
   int delay;         // In case of a video input   
   bool bwritePoints;     // Write detected feature points  
   bool bwriteExtrinsics;   // Write extrinsic parameters  
   bool calibZeroTangentDist; // Assume zero tangential distortion  
   bool calibFixPrincipalPoint;// Fix the principal point at the center  
   bool flipVertical;     // Flip the captured images around the horizontal axis  
   string outputFileName;   // The name of the file where to write  
   bool showUndistorsed;    // Show undistorted images after calibration  
   string input;        // The input ->   
     
     
     
   int cameraID;  
   vector<string> imageList;  
   int atImageList;  
   VideoCapture inputCapture;  
   InputType inputType;  
   bool goodInput;   
   int flag;  
     
 private:   
   string patternToUse;  
     
   
 };  
   
 void write(FileStorage& fs, const std::string&, const Settings& x)  
 {  
   x.write(fs);  
 }  
 void read(const FileNode& node, Settings& x, const Settings& default_value = Settings())  
 {  
   if(node.empty())  
     x = default_value;  
   else  
     x.read(node);  
 }  
   
 enum { DETECTION = 0, CAPTURING = 1, CALIBRATED = 2 };  
   
 bool runCalibrationAndSave(Settings& s, Size imageSize, Mat& cameraMatrix, Mat& distCoeffs,  
               vector<vector<Point2f> > imagePoints );  
   
 int main(int argc, char* argv[])  
 {  
   help();  
   Settings s;   
   const string inputSettingsFile = argc > 1 ? argv[1] : "default.xml";  
   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  
   
   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;  
   
   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(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,  
         CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FAST_CHECK | CV_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;  
     }  
   
     if ( found)        // If done with success,   
     {  
        // improve the found corners' coordinate accuracy for chessboard  
         if( s.calibrationPattern == Settings::CHESSBOARD)   
         {  
           Mat viewGray;  
           cvtColor(view, viewGray, CV_BGR2GRAY);   
           cornerSubPix( viewGray, pointBuf, Size(11,11),  
             Size(-1,-1), TermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_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();  
         }  
   
         // 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 = 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 = waitKey();  
       if( c == ESC_KEY || c == 'q' || c == 'Q' )  
         break;  
     }  
   }  
   
   
   return 0;  
 }  
   
 double computeReprojectionErrors( const vector<vector<Point3f> >& objectPoints,  
                  const vector<vector<Point2f> >& imagePoints,  
                  const vector<Mat>& rvecs, const vector<Mat>& tvecs,  
                  const Mat& cameraMatrix , const Mat& distCoeffs,  
                  vector<float>& perViewErrors)  
 {  
   vector<Point2f> imagePoints2;  
   int i, totalPoints = 0;  
   double totalErr = 0, err;  
   perViewErrors.resize(objectPoints.size());  
   
   for( i = 0; i < (int)objectPoints.size(); ++i )  
   {  
     projectPoints( Mat(objectPoints[i]), rvecs[i], tvecs[i], cameraMatrix,   
             distCoeffs, imagePoints2);  
     err = norm(Mat(imagePoints[i]), Mat(imagePoints2), CV_L2);  
       
     int n = (int)objectPoints[i].size();  
     perViewErrors[i] = (float) std::sqrt(err*err/n);  
     totalErr    += err*err;  
     totalPoints   += n;  
   }  
   
   return std::sqrt(totalErr/totalPoints);  
 }  
   
 void calcBoardCornerPositions(Size boardSize, float squareSize, vector<Point3f>& corners,   
              Settings::Pattern patternType /*= Settings::CHESSBOARD*/)  
 {  
   corners.clear();  
   
   switch(patternType)  
   {  
   case Settings::CHESSBOARD:  
   case Settings::CIRCLES_GRID:  
     for( int i = 0; i < boardSize.height; ++i )  
       for( int j = 0; j < boardSize.width; ++j )  
         corners.push_back(Point3f(float( j*squareSize ), float( i*squareSize ), 0));  
     break;  
   
   case Settings::ASYMMETRIC_CIRCLES_GRID:  
     for( int i = 0; i < boardSize.height; i++ )  
       for( int j = 0; j < boardSize.width; j++ )  
         corners.push_back(Point3f(float((2*j + i % 2)*squareSize), float(i*squareSize), 0));  
     break;  
   }  
 }  
   
 bool runCalibration( Settings& s, Size& imageSize, Mat& cameraMatrix, Mat& distCoeffs,   
           vector<vector<Point2f> > imagePoints, vector<Mat>& rvecs, vector<Mat>& tvecs,  
           vector<float>& reprojErrs, double& totalAvgErr)  
 {  
   
   cameraMatrix = Mat::eye(3, 3, CV_64F);  
   if( s.flag & CV_CALIB_FIX_ASPECT_RATIO )  
     cameraMatrix.at<double>(0,0) = 1.0;  
   
   distCoeffs = Mat::zeros(8, 1, CV_64F);  
   
   vector<vector<Point3f> > objectPoints(1);  
   calcBoardCornerPositions(s.boardSize, s.squareSize, objectPoints[0], s.calibrationPattern);  
   
   objectPoints.resize(imagePoints.size(),objectPoints[0]);   
   
   //Find intrinsic and extrinsic camera parameters  
   double rms = calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix,  
                  distCoeffs, rvecs, tvecs, s.flag|CV_CALIB_FIX_K4|CV_CALIB_FIX_K5);  
     
   cout << "Re-projection error reported by calibrateCamera: "<< rms << endl;  
   
   bool ok = checkRange(cameraMatrix) && checkRange(distCoeffs);  
   
   totalAvgErr = computeReprojectionErrors(objectPoints, imagePoints,  
                        rvecs, tvecs, cameraMatrix, distCoeffs, reprojErrs);  
   
   return ok;  
 }  
   
 // Print camera parameters to the output file  
 void saveCameraParams( Settings& s, Size& imageSize, Mat& cameraMatrix, Mat& distCoeffs,  
             const vector<Mat>& rvecs, const vector<Mat>& tvecs,  
             const vector<float>& reprojErrs, const vector<vector<Point2f> >& imagePoints,  
             double totalAvgErr )  
 {  
   FileStorage fs( s.outputFileName, FileStorage::WRITE );  
     
   time_t t;  
   time( &t );  
   struct tm *t2 = localtime( &t );  
   char buf[1024];  
   strftime( buf, sizeof(buf)-1, "%c", t2 );  
   
   fs << "calibration_Time" << buf;  
     
   if( !rvecs.empty() || !reprojErrs.empty() )  
     fs << "nrOfFrames" << (int)std::max(rvecs.size(), reprojErrs.size());  
   fs << "image_Width" << imageSize.width;  
   fs << "image_Height" << imageSize.height;  
   fs << "board_Width" << s.boardSize.width;  
   fs << "board_Height" << s.boardSize.height;  
   fs << "square_Size" << s.squareSize;  
     
   if( s.flag & CV_CALIB_FIX_ASPECT_RATIO )  
     fs << "FixAspectRatio" << s.aspectRatio;  
   
   if( s.flag )  
   {  
     sprintf( buf, "flags: %s%s%s%s",  
       s.flag & CV_CALIB_USE_INTRINSIC_GUESS ? " +use_intrinsic_guess" : "",  
       s.flag & CV_CALIB_FIX_ASPECT_RATIO ? " +fix_aspectRatio" : "",  
       s.flag & CV_CALIB_FIX_PRINCIPAL_POINT ? " +fix_principal_point" : "",  
       s.flag & CV_CALIB_ZERO_TANGENT_DIST ? " +zero_tangent_dist" : "" );  
     cvWriteComment( *fs, buf, 0 );  
       
   }  
     
   fs << "flagValue" << s.flag;  
   
   fs << "Camera_Matrix" << cameraMatrix;  
   fs << "Distortion_Coefficients" << distCoeffs;  
   
   fs << "Avg_Reprojection_Error" << totalAvgErr;  
   if( !reprojErrs.empty() )  
     fs << "Per_View_Reprojection_Errors" << Mat(reprojErrs);  
     
   if( !rvecs.empty() && !tvecs.empty() )  
   {  
     CV_Assert(rvecs[0].type() == tvecs[0].type());  
     Mat bigmat((int)rvecs.size(), 6, rvecs[0].type());  
     for( int i = 0; i < (int)rvecs.size(); i++ )  
     {  
       Mat r = bigmat(Range(i, i+1), Range(0,3));  
       Mat t = bigmat(Range(i, i+1), Range(3,6));  
   
       CV_Assert(rvecs[i].rows == 3 && rvecs[i].cols == 1);  
       CV_Assert(tvecs[i].rows == 3 && tvecs[i].cols == 1);  
       //*.t() is MatExpr (not Mat) so we can use assignment operator  
       r = rvecs[i].t();  
       t = tvecs[i].t();  
     }  
     cvWriteComment( *fs, "a set of 6-tuples (rotation vector + translation vector) for each view", 0 );  
     fs << "Extrinsic_Parameters" << bigmat;  
   }  
     
   if( !imagePoints.empty() )  
   {  
     Mat imagePtMat((int)imagePoints.size(), imagePoints[0].size(), CV_32FC2);  
     for( int i = 0; i < (int)imagePoints.size(); i++ )  
     {  
       Mat r = imagePtMat.row(i).reshape(2, imagePtMat.cols);  
       Mat imgpti(imagePoints[i]);  
       imgpti.copyTo(r);  
     }  
     fs << "Image_points" << imagePtMat;  
   }  
 }  
   
 bool runCalibrationAndSave(Settings& s, Size imageSize, Mat& cameraMatrix, Mat& distCoeffs,vector<vector<Point2f> > imagePoints )  
 {  
   vector<Mat> rvecs, tvecs;  
   vector<float> reprojErrs;  
   double totalAvgErr = 0;  
   
   bool ok = runCalibration(s,imageSize, cameraMatrix, distCoeffs, imagePoints, rvecs, tvecs,   
                reprojErrs, totalAvgErr);  
   cout << (ok ? "Calibration succeeded" : "Calibration failed")  
     << ". avg re projection error = " << totalAvgErr ;   
   
   if( ok )  
     saveCameraParams( s, imageSize, cameraMatrix, distCoeffs, rvecs ,tvecs, reprojErrs,  
               imagePoints, totalAvgErr);  
   return ok;  
 }  
   




3)Calibration configuration file below 

 <?xml version="1.0"?>  
 <opencv_storage>  
 <Settings>  
  <!-- Number of inner corners per a item row and column. (square, circle) -->  
  <BoardSize_Width>4</BoardSize_Width>  
  <BoardSize_Height>4</BoardSize_Height>  
  <!-- The size of a square in some user defined metric system (pixel, millimeter)-->  
  <Square_Size>30</Square_Size>  
  <!-- The type of input used for camera calibration. One of: CHESSBOARD CIRCLES_GRID ASYMMETRIC_CIRCLES_GRID -->  
  <Calibrate_Pattern>"CHESSBOARD"</Calibrate_Pattern>  
  <!-- The input to use for calibration.   
           To use an input camera -> give the ID of the camera, like "1"  
           To use an input video -> give the path of the input video, like "/tmp/x.avi"  
           To use an image list  -> give the path to the XML or YAML file containing the list of the images, like "/tmp/circles_list.xml"  
           -->  
  <Input>"0"</Input>  
  <!-- If true (non-zero) we flip the input images around the horizontal axis.-->  
  <Input_FlipAroundHorizontalAxis>0</Input_FlipAroundHorizontalAxis>  
  <!-- Time delay between frames in case of camera. -->  
  <Input_Delay>100</Input_Delay>       
  <!-- How many frames to use, for calibration. -->  
  <Calibrate_NrOfFrameToUse>10</Calibrate_NrOfFrameToUse>  
  <!-- Consider only fy as a free parameter, the ratio fx/fy stays the same as in the input cameraMatrix.   
        Use or not setting. 0 - False Non-Zero - True-->  
  <Calibrate_FixAspectRatio> 1 </Calibrate_FixAspectRatio>  
  <!-- If true (non-zero) tangential distortion coefficients are set to zeros and stay zero.-->  
  <Calibrate_AssumeZeroTangentialDistortion>1</Calibrate_AssumeZeroTangentialDistortion>  
  <!-- If true (non-zero) the principal point is not changed during the global optimization.-->  
  <Calibrate_FixPrincipalPointAtTheCenter> 1 </Calibrate_FixPrincipalPointAtTheCenter>  
  <!-- The name of the output log file. -->  
  <Write_outputFileName>"out_camera_data.xml"</Write_outputFileName>  
  <!-- If true (non-zero) we write to the output file the feature points.-->  
  <Write_DetectedFeaturePoints>1</Write_DetectedFeaturePoints>  
  <!-- If true (non-zero) we write to the output file the extrinsic camera parameters.-->  
  <Write_extrinsicParameters>1</Write_extrinsicParameters>  
  <!-- If true (non-zero) we show after calibration the undistorted images.-->  
  <Show_UndistortedImage>1</Show_UndistortedImage>  
 </Settings>  
 </opencv_storage>  

3)Build and run the executable





Video with complete procedure
------------------------------------






Code is available in the following path of opencv


opencv\samples\cpp\tutorial_code\calib3d\camera_calibration

10 comments:

Thanh Ng said...

Hi, thanks for your detailed tutorial :D but I have a problem when running this one

I have downloaded & compiled the code you provide , modify the configuration file 'in_VID5.xml' and then when I run it on command window: calib_eg.exe in_VID5.xml, it cannot run with a warning 'Could not open the configuration file: "in_VID5.xm"'.

Do you know the reason for this problem? Thanks in advanced :D

Dan Brown said...

hi dude,
your tutorial is set for release mode, but only works on Debug for me. I cant access the Release folder as it cant be built due to abundance of errors. What do you think i'm missing, to make the Release mode able to build?

thx

Anonymous said...

Please mention how to use it in the Debug mode? Thank you.

Anonymous said...

Go and Check your properties in Linker, the directory of your libs use must be
opencv_core246d.lib for debug mode, the ones without d at the back is for release mode

fercho Ryuji said...

hi Friend .. thank's for the tutorial ... but i have a problem during running the aplication..in the command line appears:
Could´n open the configuration file : default.xml
How I can correct this error?...Where do I put this file?

Please help me ñ.ñ

Lentin Joseph said...

Hi
Did you provide the xml in_VID5.xml along with the exe? You have to provide it for the calibration process

Anonymous said...

hiii,
how to do camera calibration without using camera interface? i mean justz having the photo of checker board pattern loaded

Anonymous said...

Hello, I have a problem wiht calibrating camera using .mp4 video file. It is denoted as valid XML.

M haz said...

hi.. i am a student from malaysia... thank you so much for the monocular calibration guide.. it really helpful... right now i am trying to run the stereo calibration using the same step as mono calib.. but it did not work.. can you give some explanation.. maybe a brief explanation for stereo calibration step..

Abdul Bari Chanessra said...

We put forth a comprehensive range of Commercial Weighing Scales that includes Mini .... Creating a niche of Calibration Precision Weights such as Calibration scale repair los angeles

Post a Comment