• Camera Calibration Experiment


    I use 18 images of Chess Board.

    I use OpenCv Cali cpp.

    My Camera is Iphone4.

    The Intrinsic Matrix K is:

    2473.82     0     1296.06

    0         2469.12   969.665

    0             0          1

    The code is:

    // Example 11-1. Reading a chessboard¡¯s width and height, reading and collecting the 
    //               requested number of views, and calibrating the camera
    //
    #include <cv.h>
    #include <highgui.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string>
    #include <sstream>
    #include<iomanip>
    #include<opencv2corecore.hpp>
    #include<opencv2highguihighgui.hpp>
    #include<opencv2imgprocimgproc.hpp>
    #include<opencv2calib3dcalib3d.hpp>
    #include <opencv2/features2d/features2d.hpp>
    #include<string>
    #include<vector>
    
    using namespace std;
    using namespace cv;
    void zhuanhuan(string src,char* dst) 
    {
        
        int i; 
        for(i=0;i<src.length();i++) 
            dst[i]=src[i]; 
       dst[i] = '';
         
    }
    
    
    
    
    //
    /* *************** License:**************************
       Oct. 3, 2008
       Right to use this code in any way you want without warrenty, support or any guarentee of it working.
    
       BOOK: It would be nice if you cited it:
       Learning OpenCV: Computer Vision with the OpenCV Library
         by Gary Bradski and Adrian Kaehler
         Published by O'Reilly Media, October 3, 2008
     
       AVAILABLE AT: 
         http://www.amazon.com/Learning-OpenCV-Computer-Vision-Library/dp/0596516134
         Or: http://oreilly.com/catalog/9780596516130/
         ISBN-10: 0596516134 or: ISBN-13: 978-0596516130    
    
       OTHER OPENCV SITES:
       * The source code is on sourceforge at:
         http://sourceforge.net/projects/opencvlibrary/
       * The OpenCV wiki page (As of Oct 1, 2008 this is down for changing over servers, but should come back):
         http://opencvlibrary.sourceforge.net/
       * An active user group is at:
         http://tech.groups.yahoo.com/group/OpenCV/
       * The minutes of weekly OpenCV development meetings are at:
         http://pr.willowgarage.com/wiki/OpenCV
       ************************************************** */
    //
    int n_boards = 18; //Will be set by input list
    
    int board_w=7;
    int board_h=7;
    
    
    int main() {
      
     
    
      
      
      
      int board_n  = board_w * board_h;
      CvSize board_sz = cvSize( board_w, board_h );
     
      
    
      cvNamedWindow( "Calibration" );
      cvNamedWindow( "Raw Video");
      //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* intrinsic_matrix  = cvCreateMat(3,3,CV_32FC1);
      CvMat* distortion_coeffs = cvCreateMat(5,1,CV_32FC1);
    
      CvPoint2D32f* corners = new CvPoint2D32f[ board_n ];
      int corner_count=0;
      int successes = 0;
      int step, frame = 0;
    
      
      IplImage *image1=cvLoadImage("D:\E\resource\odometry experiment\calibration\chessImg\nn1.jpg");
     
      // CAPTURE CORNER VIEWS LOOP UNTIL WE¡¯VE GOT n_boards 
      // SUCCESSFUL CAPTURES (ALL CORNERS ON THE BOARD ARE FOUND)
      //
      
    
      for (int ii = 1; ii <= n_boards; ii++)
       {
            ///¶Áȡ͌Ƭ
    
            
    
            std::stringstream s;
            s << "D:\E\resource\odometry experiment\calibration\chessImg\nn"  << ii << ".jpg";
            std::cout << s.str() << std::endl;
            string str=s.str();
            char* temp=new char[str.length()];
            zhuanhuan(str,temp);
    
            IplImage *image1=cvLoadImage(temp);
            IplImage *gray_image1 = cvCreateImage(cvGetSize(image1),8,1);//subpixel
    
      
        
            //IplImage *image1=cvLoadImage("D:\E\resource\odometry experiment\calibration\chessImg\nn12.jpg");
           
            //IplImage *gray_image1 = cvCreateImage(cvGetSize(image1),8,1);//subpixel
            cvShowImage("Image1", image1);
    
            CvSize tt=cvGetSize(image1);
            cout<<"tt.width="<<tt.width<<endl;
            cout<<"tt.height="<<tt.height<<endl;
    
    
           // cvWaitKey(0);
    
    
             cvCvtColor(image1, gray_image1, CV_BGR2GRAY);
             cvShowImage("gray_image1",gray_image1);
    
            //  cvWaitKey(0);
    
             // image1= cvCloneImage(gray_image1);
              //cvShowImage("Image1", image1);
              //cvWaitKey(0);
    
              int found = cvFindChessboardCorners(
                   image1, board_sz, corners, &corner_count, 
                   CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FILTER_QUADS  
                    );
    
           cout<<"found="<<found<<endl;
    
    
    
          cvFindCornerSubPix(gray_image1, corners, corner_count, 
                     cvSize(11,11),cvSize(-1,-1), cvTermCriteria(    
                      CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 30, 0.1 ));
     
             cvDrawChessboardCorners(image1, board_sz, corners, 
                      corner_count, found);
             cvShowImage( "Calibration", image1 );
            //cvWaitKey(0);
    
    
    
    
            if( corner_count == board_n ) {
             
              step = successes*board_n;
              for( int i=step, j=0; j<board_n; ++i,++j ) {
                 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;
    
    
                 cout<<"corners["<<j<<"].x="<<corners[j].x<<endl;
                 cout<<"corners["<<j<<"].y="<<corners[j].y<<endl;
              }
              CV_MAT_ELEM(*point_counts, int,successes,0) = board_n;    
                successes++;
           }
           else
             cvShowImage( "Calibration", gray_image1 ); //Show Gray if we didn't collect the image
    
    
      }
    
      cout<<"successes="<<successes<<endl;
    
          cvCalibrateCamera2(
          object_points, image_points,
          point_counts,  cvGetSize( image1 ),
          intrinsic_matrix, distortion_coeffs,
          NULL, NULL,0  //CV_CALIB_FIX_ASPECT_RATIO
          );
    
            int u=0,v=0;
            for (u=0;u<3;u++)
                for(v=0;v<3;v++)
                    cout<<"intrinsic_matrix["<<u<<"]["<<v<<"]=  "<<CV_MAT_ELEM(*intrinsic_matrix,float,u,v)<<endl;
      
    
        //Skip every board_dt frames to allow user to move chessboard
        
           //Find chessboard corners:
         
            
    
           /*
           //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 ) {
              cvShowImage( "Calibration", image ); //show in color if we did collect the image
              step = successes*board_n;
              for( int i=step, j=0; j<board_n; ++i,++j ) {
                 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,successes,0) = board_n;    
            
           }
           else
             cvShowImage( "Calibration", gray_image ); //Show Gray if we didn't collect the image
       
    
        
     
    
    
      }// End of for collection
    
      /*
      cvDestroyWindow("Calibration");
      printf("
    
    *** CALLIBRATING THE CAMERA...");
      //ALLOCATE MATRICES ACCORDING TO HOW MANY CHESSBOARDS FOUND
      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<9*board_n; ++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<9; ++i){ //These are all the same number
        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);
    
      // 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;
    
      //CALIBRATE THE CAMERA!
      cvCalibrateCamera2(
          object_points2, image_points2,
          point_counts2,  cvGetSize( image ),
          intrinsic_matrix, distortion_coeffs,
          NULL, NULL,0  //CV_CALIB_FIX_ASPECT_RATIO
      );
    
      // SAVE THE INTRINSICS AND DISTORTIONS
      printf(" *** DONE!
    
    Storing Intrinsics.xml and Distortions.xml files
    
    ");
      cvSave("Intrinsics.xml",intrinsic_matrix);
      cvSave("Distortion.xml",distortion_coeffs);
    
      // EXAMPLE OF LOADING THESE MATRICES BACK IN:
     
    
      // Build the undistort map which we will use for all 
      // subsequent frames.
      //
      
      // Just run the camera to the screen, now showing the raw and
      // the undistorted image.
      //
      */
    
      return 0;
    }

  • 相关阅读:
    Android布局与事件
    android 开发中共享全局数据Application的类
    从Android界面开发谈起【转】
    HttpClient java
    关于整合S&K框架的一些个小注意
    批处理执行多条语句
    Atitit. 软件设计 模式 变量 方法 命名最佳实践 vp820 attilax总结命名表大全
    atitit.软件设计模式大的总结attialx总结
    Atitit.软件开发的最终的设计 dsl化,ast化(建立ast, 解析执行ast)
    atitit。流程图的设计与制作 attilax 总结
  • 原文地址:https://www.cnblogs.com/stevenxiu/p/5670798.html
Copyright © 2020-2023  润新知