opencv标定程序

一. 标定原理

摄像机在成像的过程中会在边缘产生显著的畸变，对于普通的摄像机拍摄的图像，会产生径向畸变，切向畸变和其他类型的畸变，我们需要对图像进行矫正处理。使用opencv标定图像的过程，先根据一个标定物体计算旋转矩阵和平移向量，寻找标定物的角点cvFindchessboardCorners；再精确角点的位置（也叫亚像素角点）cvfindCornerSubPix；绘制出所有的标定物角点cvDrawChessboardCorners ；使用标定函数计算摄像机的内参数矩阵和畸变系数，旋转变量和平移变量 cvCalibrateCamera2；根据内参数矩阵和畸变系数求出畸变映射cvInitUndistortMap ，再使用重映射转换图片 cvRemap ，也可以使用cvUndistort2完成所有的事项。

二. 函数简介

1. cvFindchessboardCorners                 寻找棋盘上的角点位置
2. cvfindCornerSubPix                      精确角点位置
3. cvDrawChessboardCorners                 绘制检测到的棋盘角点
4. cvCalibrateCamera2                      利用定标来计算摄像机的内参数和外参数 
5. cvfindExtrinsicCameraParam2             只计算外参数
6. cvRodrigues2                           进行旋转矩阵和旋转向量间的转换 
7. cvUndistort2                            校正图像因相机镜头引起的变形
8. cvInitUndistortMap                      计算畸变映射
9. cvRemap                                 重映射

<寻找棋盘上的角点位置>

函数cvFindChessboardCorners试图确定输入图像是否是棋盘模式，并确定角点的位置。如果所有角点都被检测到切它们都被以一定顺序排布（一行一行地，每行从左到右），函数返回非零值，否则在函数不能发现所有角点或者记录它们地情况下，函数返回0。例如一个正常地棋盘图右8x8个方块和7x7个内角点，内角点是黑色方块相互联通地位置。这个函数检测到地坐标只是一个大约地值，如果要精确地确定它们的位置，可以使用函数cvFindCornerSubPix。

int cvFindChessboardCorners(const void* image, CvSize patternSize, CvPoint2D32f* corners, int* cornerCount=NULL, int flags=CV_CALIB_CB_ADAPTIVE_THRESH )

image 输入的棋盘图，必须是8位的灰度或者彩色图像。
pattern_size 棋盘图中每行和每列角点的个数。
corners 检测到的角点
corner_count 输出，角点的个数。如果不是NULL，函数将检测到的角点的个数存储于此变量。
flags 各种操作标志，可以是0或者下面值的组合：
CV_CALIB_CB_ADAPTIVE_THRESH - 使用自适应阈值（通过平均图像亮度计算得到）将图像转换为黑白图，而不是一个固定的阈值。
CV_CALIB_CB_NORMALIZE_IMAGE - 在利用固定阈值或者自适应的阈值进行二值化之前，先使用cvNormalizeHist来均衡化图像亮度。
CV_CALIB_CB_FILTER_QUADS - 使用其他的准则（如轮廓面积，周长，方形形状）来去除在轮廓检测阶段检测到的错误方块。

<精确角点位置>

函数 cvFindCornerSubPix 通过迭代来发现具有子象素精度的角点位置

void cvFindCornerSubPix(const CvArr* image, CvPoint2D32f* corners, int count, CvSize winSize, CvSize zeroZone, CvTermCriteria criteria)

第一个参数 image 输入图像.
第二个参数 corners 输入角点的初始坐标，也存储精确的输出坐标
第三个参数 count 角点数目
第四个参数 win 搜索窗口的一半尺寸。如果 win=(5,5) 那么使用 5*2+1 × 5*2+1 = 11 × 11 大小的搜索窗口
第五个参数 zero_zone 死区的一半尺寸，死区为不对搜索区的中央位置做求和运算的区域。它是用来避免自相关矩阵出现的某些可能的奇异性。当值为 (-1,-1) 表示没有死区。
第六个参数 criteria 求角点的迭代过程的终止条件。即角点位置的确定，要么迭代数大于某个设定值，或者是精确度达到某个设定值。 criteria 可以是最大迭代数目，或者是设定的精确度，也可以是它们的组合。

<绘制检测到的棋盘角点>

函数cvDrawChessboardCorners以红色圆圈绘制检测到的棋盘角点；如果整个棋盘都检测到，则用直线连接所有的角点。

void cvDrawChessboardCorners(CvArr* image, CvSize patternSize, CvPoint2D32f* corners, int count, int patternWasFound)

第一个参数 image 结果图像，必须是8位彩色图像。
第二个参数 pattern_size 每行和每列地内角点数目。
第三个参数 corners 检测到地角点数组。
第四个参数 count 角点数目。
第五个参数 pattern_was_found 指示完整地棋盘被发现(≠0)还是没有发现(=0)。可以传输cvFindChessboardCorners函数的返回值。

<利用定标来计算摄像机的内参数和外参数 >

函数cvCalibrateCamera2从每个视图中估计相机的内参数和外参数。

double cvCalibrateCamera2(const CvMat* objectPoints, const CvMat* imagePoints, const CvMat* pointCounts, CvSize imageSize, CvMat* cameraMatrix, CvMat* distCoeffs, CvMat* rvecs=NULL, CvMat* tvecs=NULL, int flags=0 )

第一个参数 object_points 定标点的世界坐标，为3xN或者Nx3的矩阵，这里N是所有视图中点的总数。
第二个参数 image_points 定标点的图像坐标，为2xN或者Nx2的矩阵，这里N是所有视图中点的总数。
第三个参数 point_counts 向量，指定不同视图里点的数目，1xM或者Mx1向量，M是视图数目。
第四个参数 image_size 图像大小，只用在初始化内参数时。
第五个参数 intrinsic_matrix 输出内参矩阵(A) $⎡ ⎣ ⎢ f x 00 0 f y 0 c x c y 1 ⎤ ⎦ ⎥$ $<![CDATA[// ><![CDATA[// ><!]]]]><![CDATA[> //--><!]]>$ ，如果指定CV_CALIB_USE_INTRINSIC_GUESS和（或）CV_CALIB_FIX_ASPECT_RATION，fx、 fy、 cx和cy部分或者全部必须被初始化。
第六个参数 distortion_coeffs 输出大小为4x1或者1x4的向量，里面为形变参数[k1, k2, p1, p2]。
第七个参数 rotation_vectors 输出大小为3xM或者Mx3的矩阵，里面为旋转向量（旋转矩阵的紧凑表示方式，具体参考函数cvRodrigues2）
第八个参数 translation_vectors 输出大小为3xM或Mx3的矩阵，里面为平移向量。
第九个参数 flags 不同的标志，可以是0，或者下面值的组合：
- CV_CALIB_USE_INTRINSIC_GUESS - 内参数矩阵包含fx，fy，cx和cy的初始值。否则，(cx, cy)被初始化到图像中心（这儿用到图像大小），焦距用最小平方差方式计算得到。注意，如果内部参数已知，没有必要使用这个函数，使用cvFindExtrinsicCameraParams2则可。
- CV_CALIB_FIX_PRINCIPAL_POINT - 主点在全局优化过程中不变，一直在中心位置或者在其他指定的位置（当CV_CALIB_USE_INTRINSIC_GUESS设置的时候）。
- CV_CALIB_FIX_ASPECT_RATIO - 优化过程中认为fx和fy中只有一个独立变量，保持比例fx/fy不变，fx/fy的值跟内参数矩阵初始化时的值一样。在这种情况下， (fx, fy)的实际初始值或者从输入内存矩阵中读取（当CV_CALIB_USE_INTRINSIC_GUESS被指定时），或者采用估计值（后者情况中fx和fy可能被设置为任意值，只有比值被使用）。
- CV_CALIB_ZERO_TANGENT_DIST – 切向形变参数(p1, p2)被设置为0，其值在优化过程中保持为0。

<只计算外参数>

函数cvFindExtrinsicCameraParams2使用已知的内参数和某个视图的外参数来估计相机的外参数。3维物体上的点坐标和相应的2维投影必须被指定。这个函数也可以用来最小化反投影误差。

void cvFindExtrinsicCameraParams2( const CvMat* object_points,const CvMat* image_points,const CvMat* camera_matrix,const CvMat* distortion_coeffs,CvMat* rotation_vector, CvMat* translation_vector,int use_extrinsic_guess CV_DEFAULT(0) );

第一个参数 object_points 定标点的坐标，为3xN或者Nx3的矩阵，这里N是视图中的个数。
第二个参数 image_points 定标点在图像内的坐标，为2xN或者Nx2的矩阵，这里N是视图中的个数。
第三个参数 intrinsic_matrix 内参矩阵(A) $⎡ ⎣ ⎢ f x 00 0 f y 0 c x c y 1 ⎤ ⎦ ⎥$ $<![CDATA[// ><![CDATA[// ><!]]]]><![CDATA[> //--><!]]>$ 。
第四个参数 distortion_coeffs 大小为4x1或者1x4的向量，里面为形变参数[k1,k2,p1,p2]。如果是NULL，所有的形变系数都为0。
第五个参数 rotation_vector 输出大小为3x1或者1x3的矩阵，里面为旋转向量（旋转矩阵的紧凑表示方式，具体参考函数cvRodrigues2）。
第六个参数 translation_vector 大小为3x1或1x3的矩阵，里面为平移向量。

<进行旋转矩阵和旋转向量间的转换 >

函数转换旋转向量到旋转矩阵，或者相反。旋转向量是旋转矩阵的紧凑表示形式。旋转向量的方向是旋转轴，向量的长度是围绕旋转轴的旋转角。

int  cvRodrigues2( const CvMat* src, CvMat* dst, CvMat* jacobian=0 );

第一个参数 src 输入的旋转向量（3x1或者1x3）或者旋转矩阵（3x3）。
第二个参数 dst 输出的旋转矩阵（3x3）或者旋转向量（3x1或者1x3）
第三个参数 jacobian 可选的输出雅可比矩阵（3x9或者9x3），关于输入部分的输出数组的偏导数。

<校正图像因相机镜头引起的变形>

函数cvUndistort2对图像进行变换来抵消径向和切向镜头变形。相机参数和变形参数可以通过函数cvCalibrateCamera2取得。使用本节开始时提到的公式，对每个输出图像像素计算其在输入图像中的位置，然后输出图像的像素值通过双线性插值来计算。如果图像得分辨率跟定标时用得图像分辨率不一样，fx、fy、cx和cy需要相应调整，因为形变并没有变化。

 void cvUndistort2(const CvArr* src, CvArr* dst, const CvMat* cameraMatrix, const CvMat* distCoeffs, const CvMat* newCameraMatrix=NULL )

第提个参数 src 原始图像（已经变形的图像）。
第二个参数 dst 结果图像（已经校正的图像）。
第三个参数 intrinsic_matrix 相机内参数矩阵，格式为 $⎡ ⎣ ⎢ f x 00 0 f y 0 c x c y 1 ⎤ ⎦ ⎥$ $<![CDATA[// ><![CDATA[// ><!]]]]><![CDATA[> //--><!]]>$
第四个参数 distortion_coeffs 四个变形系数组成的向量，大小为4x1或者1x4，格式为[k1,k2,p1,p2]。

<计算畸变映射>

函数cvInitUndistortMap预先计算非形变对应－正确图像的每个像素在形变图像里的坐标。这个对应可以传递给cvRemap函数（跟输入和输出图像一起）。

void cvInitUndistortMap(const CvMat* cameraMatrix, const CvMat* distCoeffs, CvArr* map1, CvArr* map2)

第一个参数 intrinsic_matrix 摄像机内参数矩阵(A) [fx 0 cx; 0 fy cy; 0 0 1].
第二个参数 distortion_coeffs 形变系数向量[k1, k2, p1, p2]，大小为4x1或者1x4。
第三个参数 mapx x坐标的对应矩阵。
第四个参数 mapy y坐标的对应矩阵。

<对图像进行普通几何变换（重映射）>

函数 cvRemap 利用下面指定的矩阵变换输入图像:
dst(x,y)<-src(mapx(x,y),mapy(x,y))
与其它几何变换类似，可以使用一些插值方法（由用户指定，译者注：同cvResize）来计算非整数坐标的像素值。

cvRemap(const CvArr* src, CvArr* dst, const CvArr* mapx, const CvArr* mapy, int flags=CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, CvScalar fillval=cvScalarAll(0) )

第一个参数 src 输入图像.
第二个参数 dst 输出图像.
第三个参数 mapx x坐标的映射 (32fC1 image).
第四个参数 mapy y坐标的映射 (32fC1 image).
第五个参数 flags 插值方法和以下开关选项的组合:
第六个参数 CV_WARP_FILL_OUTLIERS - 填充边界外的像素. 如果输出图像的部分象素落在变换后的边界外，那么它们的值设定为 fillval。
第七个参数 fillval 用来填充边界外面的值.

三. 标定程序代码

下图为本程序在vs中的配置，三个命令参数对应main中的argv【1】，argv【2】，argv【3】
argv的值

#include <cv.h>
#include <highgui.h>
#include <stdio.h>
#include <stdlib.h>

int n_boards = 0; //Will be set by input list
const int board_dt = 10;
int board_w;
int board_h;


void help(){
    printf("Calibration from disk. Call convention:\n\n"
            "  ch11_ex11_1_fromdisk board_w board_h image_list\n\n"
            "Where: board_{w,h} are the # of internal corners in the checkerboard\n"
            "       width (board_w) and height (board_h)\n"
            "       image_list is space separated list of path/filename of checkerboard\n"
            "       images\n\n"
            "Hit 'p' to pause/unpause, ESC to quit.  After calibration, press any other key to step through the images\n\n");
}

int main(int argc, char* argv[]) {

  CvCapture* capture;// = cvCreateCameraCapture( 0 );
 // assert( capture );

    if(argc != 4){
        help();
        return -1;
    }
    help();
    board_w = atoi(argv[1]);
    board_h = atoi(argv[2]);
    int board_n  = board_w * board_h;
    CvSize board_sz = cvSize( board_w, board_h );
    FILE *fptr = fopen(argv[3],"r");
    char names[2048];
    //COUNT THE NUMBER OF IMAGES:
    while(fscanf(fptr,"%s",names)==1){
        n_boards++;
    }
    rewind(fptr);

  cvNamedWindow( "Calibration" );
  //ALLOCATE STORAGE
  CvMat* image_points      = cvCreateMat(n_boards*board_n,2,CV_32FC1);
  CvMat* object_points     = cvCreateMat(n_boards*board_n,3,CV_32FC1);
  CvMat* point_counts      = cvCreateMat(n_boards,1,CV_32SC1);

///  CvMat * image_points   = cvCreateMat(1, n_boards*board_n, CV_32FC2);
///  CvMat * object_points = cvCreateMat(1, n_boards*board_n, CV_32FC3);
///  CvMat * point_counts  = cvCreateMat(1, n_boards, CV_32SC1); 

  CvMat* intrinsic_matrix  = cvCreateMat(3,3,CV_32FC1);
  CvMat* distortion_coeffs = cvCreateMat(4,1,CV_32FC1);


  IplImage* image = 0;// = cvQueryFrame( capture );
  IplImage* gray_image = 0; //for subpixel
  CvPoint2D32f* corners = new CvPoint2D32f[ board_n ];
  int corner_count;
  int successes = 0;
  int step;

  for( int frame=0; frame<n_boards; frame++ ) {
      fscanf(fptr,"%s ",names);

      if(image){
          cvReleaseImage(&image);
          image = 0;
      }
      image = cvLoadImage( names);
      if(gray_image == 0  && image) //We'll need this for subpixel accurate stuff
          gray_image = cvCreateImage(cvGetSize(image),8,1);

      if(!image)
          printf("null image\n");

      int found = cvFindChessboardCorners(
        image,
        board_sz,
        corners,
        &corner_count, 
        CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FILTER_QUADS
      );

      //Get Subpixel accuracy on those corners
      cvCvtColor(image, gray_image, CV_BGR2GRAY);
      cvFindCornerSubPix(gray_image, corners, corner_count, 
              cvSize(11,11),cvSize(-1,-1), cvTermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 30, 0.1 ));
      //Draw it

      cvDrawChessboardCorners(image, board_sz, corners, corner_count, found);
      cvShowImage( "Calibration", image );

      // If we got a good board, add it to our data
      //
      if( corner_count == board_n ) {
          step = successes*board_n;
        printf("Found = %d for %s\n",found,names);
        for( int i=step, j=0; j<board_n; ++i,++j ) {
 ///         CV_MAT_ELEM(*image_points, CvPoint2D32f,0,i) = cvPoint2D32f(corners[j].x,corners[j].y);
 ///         CV_MAT_ELEM(*object_points,CvPoint3D32f,0,i) = cvPoint3D32f(j/board_w, j%board_w, 0.0f);
          CV_MAT_ELEM(*image_points, float,i,0) = corners[j].x;
          CV_MAT_ELEM(*image_points, float,i,1) = corners[j].y;
          CV_MAT_ELEM(*object_points,float,i,0) = j/board_w;
          CV_MAT_ELEM(*object_points,float,i,1) = j%board_w;
          CV_MAT_ELEM(*object_points,float,i,2) = 0.0f;

        }
//        CV_MAT_ELEM(*point_counts, int,0,successes) = board_n;
         CV_MAT_ELEM(*point_counts, int,frame,0) = board_n;     
       successes++;
      }else
      {
          printf("Found = %d for %s    ",found,names);
          CV_MAT_ELEM(*point_counts, int,frame,0) = board_n;    
          printf("%d counts be found!\n", corner_count);
      }

 //    if( successes == n_boards ) break;

    int c = cvWaitKey(15);
    if(c == 'p') {
        c = 0;
        while(c != 'p' && c != 27){
            c = cvWaitKey(250);
        }
    }
    if(c == 27)
        return 0;
  }
    printf("successes = %d, n_boards=%d\n",successes,n_boards);
  //ALLOCATE MATRICES ACCORDING TO HOW MANY IMAGES WE FOUND CHESSBOARDS ON
///  CvMat* image_points2      = cvCreateMat(1,successes*board_n,CV_32FC2);
///  CvMat* object_points2     = cvCreateMat(1,successes*board_n,CV_32FC3);
///  CvMat* point_counts2      = cvCreateMat(1,successes,CV_32SC1);
  CvMat* object_points2     = cvCreateMat(successes*board_n,3,CV_32FC1);
  CvMat* image_points2      = cvCreateMat(successes*board_n,2,CV_32FC1);
  CvMat* point_counts2      = cvCreateMat(successes,1,CV_32SC1);
  //TRANSFER THE POINTS INTO THE CORRECT SIZE MATRICES
  for(int i = 0; i<successes*board_n; ++i){
///      CV_MAT_ELEM(*image_points2, CvPoint2D32f,0,i)  = CV_MAT_ELEM(*image_points, CvPoint2D32f,0,i);
///      CV_MAT_ELEM(*object_points2,CvPoint3D32f,0,i)  = CV_MAT_ELEM(*object_points,CvPoint3D32f,0,i);
          CV_MAT_ELEM(*image_points2, float,i,0)    =   CV_MAT_ELEM(*image_points, float,i,0);
          CV_MAT_ELEM(*image_points2, float,i,1)    =   CV_MAT_ELEM(*image_points, float,i,1);
          CV_MAT_ELEM(*object_points2,float,i,0) = CV_MAT_ELEM(*object_points,float,i,0) ;
          CV_MAT_ELEM(*object_points2,float,i,1) = CV_MAT_ELEM(*object_points,float,i,1) ;
          CV_MAT_ELEM(*object_points2,float,i,2) = CV_MAT_ELEM(*object_points,float,i,2) ;

  } 
  for(int i=0; i<successes; ++i){
///     CV_MAT_ELEM(*point_counts2,int,0, i) = CV_MAT_ELEM(*point_counts, int,0,i);
        CV_MAT_ELEM(*point_counts2,int,i, 0) = CV_MAT_ELEM(*point_counts, int,i,0);
  }
//   cvReleaseMat(&object_points);
//   cvReleaseMat(&image_points);
//   cvReleaseMat(&point_counts);

 // cvWaitKey();//Now we have to reallocate the matrices
 // return 0;
  // At this point we have all of the chessboard corners we need.
  //

    // Initialize the intrinsic matrix such that the two focal
    // lengths have a ratio of 1.0
    //
    CV_MAT_ELEM( *intrinsic_matrix, float, 0, 0 ) = 1.0f;
    CV_MAT_ELEM( *intrinsic_matrix, float, 1, 1 ) = 1.0f;
//printf("cvCalibrateCamera2\n");
    cvCalibrateCamera2(
      object_points2,
      image_points2,
      point_counts2,
      cvGetSize( image ),
      intrinsic_matrix,
      distortion_coeffs,
      NULL,
      NULL,
      0//CV_CALIB_FIX_ASPECT_RATIO
    );
  // Save our work
  cvSave("Intrinsics.xml",intrinsic_matrix);
  cvSave("Distortion.xml",distortion_coeffs);
  // Load test
  CvMat *intrinsic = (CvMat*)cvLoad("Intrinsics.xml");
  CvMat *distortion = (CvMat*)cvLoad("Distortion.xml");

  // Build the undistort map which we will use for all 
  // subsequent frames.
  //
  IplImage* mapx = cvCreateImage( cvGetSize(image), IPL_DEPTH_32F, 1 );
  IplImage* mapy = cvCreateImage( cvGetSize(image), IPL_DEPTH_32F, 1 );
//  printf("cvInitUndistortMap\n");
  cvInitUndistortMap(
    intrinsic,
    distortion,
    mapx,
    mapy
  );
  // Just run the camera to the screen, now only showing the undistorted
  // image.
  //
  rewind(fptr);
  cvNamedWindow( "Undistort" );
  printf("\n\nPress any key to step through the images, ESC to quit\n\n");
  while(fscanf(fptr,"%s ",names)==1){
      if(image){
          cvReleaseImage(&image);
          image = 0;
      }  
      image = cvLoadImage( names);
      IplImage *t = cvCloneImage(image);
      IplImage *t2 = cvCreateImage(cvSize(t->width/2, t->height/2),t->depth, t->nChannels);
      IplImage *t3 = cvCreateImage(cvSize(t->width/2, t->height/2),t->depth, t->nChannels);
      cvResize(image, t2);

      cvShowImage( "Calibration", t2 );
      cvRemap( t, image, mapx, mapy );
      cvReleaseImage(&t);
//    cvUndistort2(
      cvResize(image, t3);
      cvShowImage("Undistort", t3);

    if((cvWaitKey()&0x7F) == 27) break;
    cvReleaseImage(&t2);
    cvReleaseImage(&t3);
  }

  return 0;
}