相机的校正感悟

 1 #ifndef CAMERACALIBRATOR_H
 2 #define CAMERACALIBRATOR_H
 3 
 4 #include <vector>
 5 #include <iostream>
 6 
 7 #include <opencv2/core/core.hpp>
 8 #include "opencv2/imgproc/imgproc.hpp"
 9 #include "opencv2/calib3d/calib3d.hpp"
10 #include <opencv2/highgui/highgui.hpp>
11 
12 class CameraCalibrator {
13 
14     // input points
15     std::vector<std::vector<cv::Point3f>> objectPoints;
16     std::vector<std::vector<cv::Point2f>> imagePoints;
17     // output Matrices
18     cv::Mat cameraMatrix;
19     cv::Mat distCoeffs;
20     // flag to specify how calibration is done
21     int flag;
22     // used in image undistortion 
23     cv::Mat map1,map2; 
24     bool mustInitUndistort;
25 
26   public:
27     CameraCalibrator() : flag(0), mustInitUndistort(true) {};
28 
29     // Open the chessboard images and extract corner points
30     int addChessboardPoints(const std::vector<std::string>& filelist, cv::Size & boardSize);
31     // Add scene points and corresponding image points
32     void addPoints(const std::vector<cv::Point2f>& imageCorners, const std::vector<cv::Point3f>& objectCorners);
33     // Calibrate the camera
34     double calibrate(cv::Size &imageSize);
35     // Set the calibration flag
36     void setCalibrationFlag(bool radial8CoeffEnabled=false, bool tangentialParamEnabled=false);
37     // Remove distortion in an image (after calibration)
38     cv::Mat CameraCalibrator::remap(const cv::Mat &image);
39 
40     // Getters
41     cv::Mat getCameraMatrix() { return cameraMatrix; }
42     cv::Mat getDistCoeffs()   { return distCoeffs; }
43 };
44 
45 #endif // CAMERACALIBRATOR_H

  1 #include "CameraCalibrator.h"
  2 
  3 // Open chessboard images and extract corner points
  4 int CameraCalibrator::addChessboardPoints(
  5          const std::vector<std::string>& filelist, 
  6          cv::Size & boardSize) {
  7 
  8     // the points on the chessboard
  9     std::vector<cv::Point2f> imageCorners;
 10     std::vector<cv::Point3f> objectCorners;
 11 
 12     // 3D Scene Points:
 13     // Initialize the chessboard corners 
 14     // in the chessboard reference frame
 15     // The corners are at 3D location (X,Y,Z)= (i,j,0)
 16     for (int i=0; i<boardSize.height; i++) {
 17         for (int j=0; j<boardSize.width; j++) {
 18 
 19             objectCorners.push_back(cv::Point3f(i, j, 0.0f));
 20         }
 21     }
 22 
 23     // 2D Image points:
 24     cv::Mat image; // to contain chessboard image
 25     int successes = 0;
 26     // for all viewpoints
 27     for (int i=0; i<filelist.size(); i++) {
 28 
 29         // Open the image
 30         image = cv::imread(filelist[i],0);
 31 
 32         // Get the chessboard corners
 33         bool found = cv::findChessboardCorners(
 34                         image, boardSize, imageCorners);
 35 
 36         // Get subpixel accuracy on the corners
 37         cv::cornerSubPix(image, imageCorners, 
 38                   cv::Size(5,5), 
 39                   cv::Size(-1,-1), 
 40             cv::TermCriteria(cv::TermCriteria::MAX_ITER +
 41                           cv::TermCriteria::EPS, 
 42              30,        // max number of iterations 
 43              0.1));     // min accuracy
 44 
 45           // If we have a good board, add it to our data
 46           if (imageCorners.size() == boardSize.area()) {
 47 
 48             // Add image and scene points from one view
 49             addPoints(imageCorners, objectCorners);
 50             successes++;
 51           }
 52 
 53         //Draw the corners
 54         cv::drawChessboardCorners(image, boardSize, imageCorners, found);
 55         cv::imshow("Corners on Chessboard", image);
 56         cv::waitKey(100);
 57     }
 58 
 59     return successes;
 60 }
 61 
 62 // Add scene points and corresponding image points
 63 void CameraCalibrator::addPoints(const std::vector<cv::Point2f>& imageCorners, const std::vector<cv::Point3f>& objectCorners) {
 64 
 65     // 2D image points from one view
 66     imagePoints.push_back(imageCorners);          
 67     // corresponding 3D scene points
 68     objectPoints.push_back(objectCorners);
 69 }
 70 
 71 // Calibrate the camera
 72 // returns the re-projection error
 73 double CameraCalibrator::calibrate(cv::Size &imageSize)
 74 {
 75     // undistorter must be reinitialized
 76     mustInitUndistort= true;
 77 
 78     //Output rotations and translations
 79     std::vector<cv::Mat> rvecs, tvecs;
 80 
 81     // start calibration
 82     return 
 83      calibrateCamera(objectPoints, // the 3D points
 84                     imagePoints,  // the image points
 85                     imageSize,    // image size
 86                     cameraMatrix, // output camera matrix
 87                     distCoeffs,   // output distortion matrix
 88                     rvecs, tvecs, // Rs, Ts 
 89                     flag);        // set options
 90 //                    ,CV_CALIB_USE_INTRINSIC_GUESS);
 91 
 92 }
 93 
 94 // remove distortion in an image (after calibration)
 95 cv::Mat CameraCalibrator::remap(const cv::Mat &image) {
 96 
 97     cv::Mat undistorted;
 98 
 99     if (mustInitUndistort) { // called once per calibration
100     
101         cv::initUndistortRectifyMap(
102             cameraMatrix,  // computed camera matrix
103             distCoeffs,    // computed distortion matrix
104             cv::Mat(),     // optional rectification (none) 
105             cv::Mat(),     // camera matrix to generate undistorted
106             cv::Size(640,480),
107 //            image.size(),  // size of undistorted
108             CV_32FC1,      // type of output map
109             map1, map2);   // the x and y mapping functions
110 
111         mustInitUndistort= false;
112     }
113 
114     // Apply mapping functions
115     cv::remap(image, undistorted, map1, map2, 
116         cv::INTER_LINEAR); // interpolation type
117 
118     return undistorted;
119 }
120 
121 
122 // Set the calibration options
123 // 8radialCoeffEnabled should be true if 8 radial coefficients are required (5 is default)
124 // tangentialParamEnabled should be true if tangeantial distortion is present
125 void CameraCalibrator::setCalibrationFlag(bool radial8CoeffEnabled, bool tangentialParamEnabled) {
126 
127     // Set the flag used in cv::calibrateCamera()
128     flag = 0;
129     if (!tangentialParamEnabled) flag += CV_CALIB_ZERO_TANGENT_DIST;
130     if (radial8CoeffEnabled) flag += CV_CALIB_RATIONAL_MODEL;
131 }