opencv学习系列：实例练习（含多个实例）

//-----------------------------------OpenCV学习（续9月份）------------------------------------- 
//  程序名称:OpenCV程序模板样式
//  所用IDE版本：        Visual Studio 2013    
//  开发所用OpenCV版本：        2.4.9    
//  2016年10月 Created by 孙立波    

//包含程序所依赖的头文件:为方便起见把经常用的头文件都写在这里（前三必须包含），也可以用#include "opencv.hpp"包含下面所有头文件
#include <opencv2\core\core.hpp>    //程序库核心功能，基本数据与结构和算法函数
#include <opencv2\imgproc\imgproc.hpp>  //包含主要的图像处理函数
#include <opencv2\highgui\highgui.hpp>  //包含图像、视频读写函数和部分用户界面函数 

//出现#include "cv.h"表示老式风格，并包含老式所有头文件
//#include <opencv2\features2d\features2d.hpp> //包含特征点检测器、描述子及特征点匹配框架  
//#include <opencv2\nonfree\nonfree.hpp>         //SURF和SIFT会用到 

#include <iostream>  

//包含程序所使用的命名空间
using namespace cv;         //opencv2的名字空间
using namespace std;

//描述：控制台应用程序的入口函数，程序从这里开始执行??

int main(int argc, char** argv)     //argv相当于"行"指针
{

    return 0;
 }
**************************************************************************************************************

//-----------------------------------OpenCV学习15------------------------------------- 
//  程序名称:生成标定板
//  2016年10月 Created by孙立波（Visual Studio 2013+OpenCV2.4.9）
#include <opencv2\opencv.hpp> 
#include <iostream>
#include <string> 
using namespace cv;
using namespace std;
//隐藏控制台窗口
#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")

int main(int argc, char*argv[])
{
    int width = 140;//棋盘格宽度
    int height = 140;//棋盘格高度
    IplImage *src = cvCreateImage(cvSize(1120, 1120), IPL_DEPTH_8U, 1);
    cvZero(src);
    for (int i = 0; i<src->width; i++)
    {
        for (int j = 0; j<src->height; j++)
        {
            if ((i / width + j / height) % 2 == 0)
            {
                src->imageData[i*src->widthStep + j*src->nChannels] = 255;
            }
        }
    }

    cvNamedWindow("src");
    cvShowImage("src", src);

    cvSaveImage("ChessBoard.bmp", src, 0);
    cvWaitKey(0);

    return 0;


}


// ----------------------------------OpenCV学习16-------------------------------------
//  程序摘要：读取视频序列；
/*  自定义视频处理类VideoProcessor：可以处理视频和独立的图像序列，前者用以前的帧处理函数（回调函数process），
    后者用自定义的帧处理类(FrameProcessor类接口即对象->process方法);其中用到了canny函数，其中涉及把每帧图像彩色转灰度和用Canny和
    threshold函数*/
//  还包括写入视频帧类VideoWriter，在VideoProcessor的方法中应用写入类实例的成员函数，也分为处理视频和独立的图像序列即用到成员函数重载
//  以上描述为：程序后半段用自定义视频处理类封装视频捕捉类、帧处理类和视频帧写入类
//  2016年10月 Created by孙立波（Visual Studio 2013+OpenCV2.4.9）
#include <opencv2\opencv.hpp> 
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
using namespace cv;
using namespace std;

#include "videoprocessor.h"

void draw(const cv::Mat& img, cv::Mat& out) {

    img.copyTo(out);
    cv::circle(out, cv::Point(100, 100), 5, cv::Scalar(255, 0, 0), 2);
}

// processing function此函数定义用于真正的图像处理，为回调函数在main中注册后每次执行的函数处理
void canny(cv::Mat& img, cv::Mat& out) {

    // Convert to gray
    if (img.channels() == 3)
        cv::cvtColor(img, out, CV_BGR2GRAY);
    // Compute Canny edges
    cv::Canny(out, out, 100, 200);
    // Invert the image
    cv::threshold(out, out, 128, 255, cv::THRESH_BINARY_INV);
}

int main()
{
    // 打开视频文件
    cv::VideoCapture capture("D:\\workplace\\opencv_training\\bike.avi");
    //cv::VideoCapture capture("http://www.laganiere.name/bike.avi");
    // 核实视频文件是否却是打开
    if (!capture.isOpened())
        return 1;
    // Get the frame rate
    double rate = capture.get(CV_CAP_PROP_FPS);
    std::cout << "Frame rate: " << rate << "fps" << std::endl;

    bool stop(false);
    cv::Mat frame; // current video frame
    cv::namedWindow("Extracted Frame");

    // Delay between each frame
    // corresponds to video frame rate
    int delay = 1000 / rate;//视频播放按原始帧率，可设置使视频快进或倒退
    long long i = 0;
    std::string b = "bike";
    std::string ext = ".bmp";
    // for all frames in video
    while (!stop) {

        // read next frame if any
        if (!capture.read(frame))
            break;

        cv::imshow("Extra   cted Frame", frame);

        std::string name(b);
        // note: some MinGW compilers generate an error for this line
        // this is a compiler bug
        // try: std::ostringstream ss; ss << i; name+= ss.rdbuf(); i++;
        //      name+=std::to_string(i++);
        std::ostringstream ss; ss << i; name += ss.str(); i++;
        name += ext;

        std::cout << name << std::endl;

        cv::imwrite(name, frame);

        // introduce a delay
        // or press key to stop
        if (cv::waitKey(delay) >= 0)//当超过指定时间，没有按键盘时，返回值-1
            stop = true;
    }

    // Close the video file
    capture.release();

    cv::waitKey();

    // Now using the VideoProcessor class用自定义视频处理类封装视频捕捉类、帧处理类和视频帧写入类

    // Create instance
    VideoProcessor processor;

    // Open video file
    processor.setInput("D:\\workplace\\opencv_training\\bike.avi");

    // Declare a window to display the video注册窗口内存预备显示用
    processor.displayInput("Input Video");//彩色图像
    processor.displayOutput("Output Video");//灰度图像

    // Play the video at the original frame rate
    processor.setDelay(1000. / processor.getFrameRate());

    // 此为注册回调函数Set the frame processor callback function*****设置类的实例的回调函数方法为main前声明的canny（）函数！！！
    processor.setFrameProcessor(canny);

    // output a video
    //传入值-1代表不采用与输入一致的编解码方式，而是提供MFC供选择，15代表帧的速率
    processor.setOutput("D:\\workplace\\opencv_training\\bike1.avi", -1, 15);

    // stop the process at this frame，只处理前51帧并保存到内存
    processor.stopAtFrameNo(51);

    // Start the process
    processor.run();

    cv::waitKey();

    return 0;
}
//-----------------------------------OpenCV学习17------------------------------------- 
//  程序名称:利用OpenCV做标定板，可自定义！！！
//  2016年10月 Created by孙立波（Visual Studio 2013+OpenCV2.4.9）
#include <opencv2\opencv.hpp> 
#include <iostream>
#include <string> 
using namespace cv;
using namespace std;
int main()
{
    //---生成标定图

    int dd = 80;        //棋盘格大小，像素为单位
    int dx = 3;     //行：白块开头，竖着格数为6.竖向为4个焦点
    int dy = 4;     //列：白块开头，横格数为8,横向为6个角点
    //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    //注意：Size第一个为行，第二个为列！！
    Mat img(Size(2 * dy * dd,2 * dx * dd), CV_8UC1, Scalar(0));
    imshow("sss", img);
    int flag = 0;
    for (int i = 0; i < 2 * dx; i++)
    for (int j = 0; j < 2 * dy; j++)
    {
        flag = (i + j) % 2;
        if (flag == 0)
        {
            for (int m = i*dd; m < (i + 1)*dd; m++)
            for (int n = j*dd; n < (j + 1)*dd; n++)
                //or((uchar *)(img.data + m * img.step))[n] = 255;
            (*(img.data + m * img.step+n * img.elemSize())) = 255;
            //elemSize为一个像素所占用字节个数
            //*(img->imageData+m*img->widthStep+n)=255;
        }

    }
    //---END生成标定图
    imwrite("棋盘格标定图.bmp", img);
    cvNamedWindow("棋盘格", 1);
    imshow("棋盘格", img);
    cvWaitKey(0);
    cvDestroyWindow("棋盘格");
}
//-----------------------------------OpenCV学习17------------------------------------- 
//  程序名称:利用OpenCV做标定板，标定图的格子大小80*80像素,共10*10个黑白格
//  2016年10月 Created by孙立波（Visual Studio 2013+OpenCV2.4.9）
#include <opencv2\opencv.hpp> 
#include <iostream>
#include <string> 
using namespace cv;
using namespace std;
int main()
{
    //---生成标定图

    int dx = 80;        //棋盘格大小，像素为单位
    int dy = 5;     //棋盘格数目
    Mat img(Size(2 * dx*dy, 2 * dx*dy), CV_8UC1, Scalar(0));
    int flag = 0;
    for (int i = 0; i<2 * dy; i++)
    for (int j = 0; j<2 * dy; j++)
    {
        flag = (i + j) % 2;
        if (flag == 0)
        {
            for (int m = i*dx; m<(i + 1)*dx; m++)
            for (int n = j*dx; n<(j + 1)*dx; n++)
            ((uchar *)(img.data + m * img.step))[n] = 255;
            //or(*(img.data + m * img.step+n * img.elemSize())) = 255;
            //elemSize为一个像素所占用字节个数
            //*(img->imageData+m*img->widthStep+n)=255;
        }

    }
    //---END生成标定图
    imwrite("棋盘格标定图.bmp", img);
    cvNamedWindow("棋盘格", 1);
    imshow("棋盘格", img);
    cvWaitKey(0);
    cvDestroyWindow("棋盘格");
}
//-----------------------------------OpenCV学习18------------------------------------- 
//  程序名称:标定
//  2016年10月 Created by孙立波（Visual Studio 2013+OpenCV2.4.9）
#include <opencv2\opencv.hpp> 
#include <iostream>
#include <string> 
#include <vector>
#include <iomanip>
#include <fstream>
using namespace cv;
using namespace std;
int main()
{
    double time0 = static_cast<double>(getTickCount());
    ofstream fout("caliberation_result.txt");  /**    保存定标结果的文件     **/

    /************************************************************************
    读取每一幅图像，从中提取出角点，然后对角点进行亚像素精确化
    *************************************************************************/
    cout << "开始提取角点………………" << endl;
    int image_count = 21;                     /****    图像数量        ****/
    Size image_size;                          /****    图像的尺寸      ****/
    Size board_size = Size(9, 6);             /****    定标板上每行、列的角点数       ****/
    vector<Point2f> corners;                  /****    缓存每幅图像上检测到的角点     ****/
    vector<vector<Point2f>>  corners_Seq;     /****    保存检测到的所有角点           ****/
    vector<Mat>  image_Seq;


    int count = 0;
    for (int i = 0; i != image_count; i++)
    {
        cout << "Frame #" << i + 1 << "..." << endl;
        /*或者：
        std::stringstream StrStm;
        //为了将i转化为字符型，用StrStm做中介
        StrStm << i + 1;
        StrStm >> imageFileName;
        imageFileName += ".jpg";
        Mat image = imread("D:\\workplace\\opencv_training\\mytrainings\\mytest4\\color2\\img" + imageFileName);
        */
        std::stringstream str;
        str << "D:\\workplace\\opencv_training\\mytrainings\\mytest5\\color3\\img" << std::setw(2) << std::setfill('0') << i + 1 << ".jpg";
        std::cout << str.str() << std::endl;
        Mat image = cv::imread(str.str());
        image_size = image.size();
        //image_size = Size(image.cols , image.rows);
        /* 提取角点 */
        Mat imageGray;
        cvtColor(image, imageGray, CV_RGB2GRAY);
        bool patternfound = findChessboardCorners(image, board_size, corners, CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE +
            CALIB_CB_FAST_CHECK);
        if (!patternfound)
        {
            cout << "can not find chessboard corners!\n";
            continue;
            exit(1);
        }
        else
        {
            /*
            亚像素精确化 :迭代过程的终止条件可以是最大迭代次数CV_TERMCRIT_ITER类型，或者是设定的精度CV_TERMCRIT_EPS类型(或者是两
            者的组合)。终止条件的设置在极大程度上影响最终得到的亚像素值的精度。在此，指定为0.10，则求得的亚像素级精度为像素的十分
            之一
            */
            cornerSubPix(imageGray, corners, Size(11, 11), Size(-1, -1), TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
            //Size(11, 11)为搜索窗口的一半尺寸，Size(-1, -1)死区的一半尺寸，死区为不对搜索区的中央位置做求和运算的区域。/
            //它是用来避免自相关矩阵出现的某些可能的奇异性。当值为（-1，-1）表示没有死区。
            //TermCriteria为求角点的迭代过程的终止条件。即角点位置的确定，要么迭代数大于某个设定值，或者是精确懂达到某个设定值。
            //criteria可以是最大迭代数目，或者是设定的精确度，也可以是它们的组合。
            /* 绘制检测到的角点并保存 */
            Mat imageTemp = image.clone();
            for (int j = 0; j < corners.size(); j++)
            {
                circle(imageTemp, corners[j], 10, Scalar(0, 0, 255), 2, 8, 0);
            }
            string imageFileName;
            std::stringstream StrStm;
            StrStm << i + 1;
            StrStm >> imageFileName;
            imageFileName += "_corner.jpg";
            //保存提取角点的图像
            imwrite(imageFileName, imageTemp);
            cout << "Frame corner#" << i + 1 << "...end" << endl;

            count = count + corners.size();
            //将该角点压入角点序列堆栈
            corners_Seq.push_back(corners);
        }
        //将处理过的图像压入源图像堆栈
        image_Seq.push_back(image);
    }
    cout << "角点提取完成！\n";

    /************************************************************************
    摄像机定标
    *************************************************************************/
    cout << "开始定标………………" << endl;
    Size square_size = Size(20, 20);                                      /**** 实际测量得到的定标板上每个棋盘格的大小 ****/
    vector<vector<Point3f>>  object_Points;                               /**** 保存定标板上角点的三维坐标   ****/


    Mat image_points = Mat(1, count, CV_32FC2, Scalar::all(0));          /***** 保存提取的所有角点   *****/
    vector<int>  point_counts;                                           /***** 每幅图像中角点的数量 ****/
    Mat intrinsic_matrix = Mat(3, 3, CV_32FC1, Scalar::all(0));          /***** 摄像机内参数矩阵    ****/
    Mat distortion_coeffs = Mat(1, 4, CV_32FC1, Scalar::all(0));         /* 摄像机的4个畸变系数：k1,k2,p1,p2 */
    vector<cv::Mat> rotation_vectors;                                    /* 每幅图像的旋转向量 */
    vector<cv::Mat> translation_vectors;                                 /* 每幅图像的平移向量 */

    /* 初始化定标板上角点的三维坐标 */
    for (int t = 0; t<image_count; t++)
    {
        vector<Point3f> tempPointSet;
        for (int i = 0; i<board_size.height; i++)
        {
            for (int j = 0; j<board_size.width; j++)
            {
                /* 假设定标板放在世界坐标系中z=0的平面上 */
                Point3f tempPoint;
                //在这里，坐标为位置的单位为：当棋盘格子为单位长度，则代表width、height为1，当为边长为20，代表width、height为20
                tempPoint.x = i*square_size.width;
                tempPoint.y = j*square_size.height;
                tempPoint.z = 0;
                tempPointSet.push_back(tempPoint);
            }
        }
        object_Points.push_back(tempPointSet);
    }

    /* 初始化每幅图像中的角点数量，这里我们假设每幅图像中都可以看到完整的定标板 */
    for (int i = 0; i< image_count; i++)
    {
        point_counts.push_back(board_size.width*board_size.height);
    }

    /* 开始定标 */
    calibrateCamera(object_Points, corners_Seq, image_size, intrinsic_matrix, distortion_coeffs, rotation_vectors, translation_vectors, 0);
    cout << "定标完成！\n";

    /************************************************************************
    对定标结果进行评价
    *************************************************************************/
    cout << "开始评价定标结果………………" << endl;
    double total_err = 0.0;                   /* 所有图像的平均误差的总和 */
    double err = 0.0;                        /* 每幅图像的平均误差 */
    vector<Point2f>  image_points2;             /****   保存重新计算得到的投影点    ****/

    cout << "每幅图像的定标误差：" << endl;
    fout << "每幅图像的定标误差：" << endl << endl;
    for (int i = 0; i<image_count; i++)
    {
        vector<Point3f> tempPointSet = object_Points[i];
        /****    通过得到的摄像机内外参数，对空间的三维点进行重新投影计算，得到新的投影点     ****/
        projectPoints(tempPointSet, rotation_vectors[i], translation_vectors[i], intrinsic_matrix, distortion_coeffs, image_points2);
        /* 计算新的投影点和旧的投影点之间的误差*/
        vector<Point2f> tempImagePoint = corners_Seq[i];
        Mat tempImagePointMat = Mat(1, tempImagePoint.size(), CV_32FC2);
        Mat image_points2Mat = Mat(1, image_points2.size(), CV_32FC2);
        for (size_t i = 0; i != tempImagePoint.size(); i++)
        {
            image_points2Mat.at<Vec2f>(0, i) = Vec2f(image_points2[i].x, image_points2[i].y);
            tempImagePointMat.at<Vec2f>(0, i) = Vec2f(tempImagePoint[i].x, tempImagePoint[i].y);
        }
        err = norm(image_points2Mat, tempImagePointMat, NORM_L2);
        total_err += err /= point_counts[i];
        cout << "第" << i + 1 << "幅图像的平均误差：" << err << "像素" << endl;
        fout << "第" << i + 1 << "幅图像的平均误差：" << err << "像素" << endl;
    }
    cout << "总体平均误差：" << total_err / image_count << "像素" << endl;
    fout << "总体平均误差：" << total_err / image_count << "像素" << endl << endl;
    cout << "评价完成！" << endl;

    /************************************************************************
    保存定标结果
    *************************************************************************/
    cout << "开始保存定标结果………………" << endl;
    Mat rotation_matrix = Mat(3, 3, CV_32FC1, Scalar::all(0)); /* 保存每幅图像的旋转矩阵 */

    fout << "相机内参数矩阵：" << endl;
    cout << "相机内参数矩阵：" << endl;
    fout << intrinsic_matrix << endl;
    cout << intrinsic_matrix << endl;
    fout << "畸变系数：\n";
    cout << "畸变系数：\n";
    fout << distortion_coeffs << endl;
    cout << distortion_coeffs << endl;
    for (int i = 0; i<image_count; i++)
    {
        fout << "第" << i + 1 << "幅图像的旋转向量：" << endl;
        fout << rotation_vectors[i] << endl;

        /* 将旋转向量转换为相对应的旋转矩阵 */
        Rodrigues(rotation_vectors[i], rotation_matrix);
        fout << "第" << i + 1 << "幅图像的旋转矩阵：" << endl;
        fout << rotation_matrix << endl;
        fout << "第" << i + 1 << "幅图像的平移向量：" << endl;
        fout << translation_vectors[i] << endl;
    }
    cout << "完成保存" << endl;
    fout << endl;


    /************************************************************************
    显示定标结果
    *************************************************************************/
    Mat mapx = Mat(image_size, CV_32FC1);
    Mat mapy = Mat(image_size, CV_32FC1);
    Mat R = Mat::eye(3, 3, CV_32F);
    cout << "保存矫正图像" << endl;
    for (int i = 0; i != image_count; i++)
    {
        cout << "Frame #" << i + 1 << "..." << endl;
        //newCameraMatrix——输入的校正后的3X3摄像机矩阵（也可用cvStereoRectify()得出的3X4的左或右投影矩阵，其实系统会自动提取该
        //矩阵前三列的有用部分作为输入参数）注：！！无校正变换的相机仍用求得内参矩阵
        Mat newCameraMatrix = Mat(3, 3, CV_32FC1, Scalar::all(0));
        //得到映射关系:R——输入的第一和第二相机坐标系之间的旋转矩阵,一般般无校正变换的相机，默认为单位矩阵
        // opencv中，remap与undistortion都是消除畸变的函数，undistortion在设置了一些参数后调用了remap函数，二者的算法实质是一样
        //的。由目标图像的坐标，找到对应的原始图像坐标，然后将其值复制到目标图像。大致思路是如此，由于图像大小和变换，需要插值或
        //近似的方法，如最邻近法、线性插值等
        initUndistortRectifyMap(intrinsic_matrix, distortion_coeffs, R, intrinsic_matrix, image_size, CV_32FC1, mapx, mapy);
        Mat t = image_Seq[i].clone();
        cv::remap(image_Seq[i], t, mapx, mapy, INTER_LINEAR);
        string imageFileName;
        std::stringstream StrStm;
        StrStm << i + 1;
        StrStm >> imageFileName;
        imageFileName += "_校正图像.jpg";
        imwrite(imageFileName, t);
    }
    cout << "保存结束" << endl;

    time0 = ((double)getTickCount() - time0) / getTickFrequency();
    cout << "标定用时:" << time0 << "秒" << endl;
    waitKey(0);
    /************************************************************************
    测试一张图片,用标定过参数去校正畸变，并记所用时间
    *************************************************************************/
    double time1 = static_cast<double>(getTickCount());
    if (1)
    {
        cout << "TestImage ..." << endl;
        //newCameraMatrix——输入的校正后的3X3摄像机矩阵（也可用cvStereoRectify()得出的3X4的左或右投影矩阵，其实系统会自动提取该
        //矩阵前三列的有用部分作为输入参数）
        Mat newCameraMatrix = Mat(3, 3, CV_32FC1, Scalar::all(0));
        Mat testImage = imread("D:\\workplace\\opencv_training\\mytrainings\\mytest5\\color3\\img03.jpg", 1);
        initUndistortRectifyMap(intrinsic_matrix, distortion_coeffs, R, intrinsic_matrix, image_size, CV_32FC1, mapx, mapy);
        Mat t = testImage.clone();
        cv::remap(testImage, t, mapx, mapy, INTER_LINEAR);

        imwrite("img03_TestOutput.jpg", t);
        cout << "保存结束" << endl;
    }
    time1 = ((double)getTickCount() - time1) / getTickFrequency();
    cout << "一张图片的畸变校正用时:" << time1 << "秒" << endl;

    waitKey(0);
    return 0;
}
//-----------------------------------OpenCV学习19------------------------------------- 
//  程序名称:练习基于特征的ORB、SIFT、SURF特征匹配，并练习找单应性矩阵，将1图片映射到2图片坐标中，
//  用框线标出
//  2016年10月 Created by孙立波（Visual Studio 2013+OpenCV2.4.9）
#include <opencv2\opencv.hpp> 
#include <opencv2\opencv.hpp> 
#include <iostream>
#include <string> 
using namespace cv;
using namespace std;
#include <vector>     
#include<opencv2/legacy/legacy.hpp>//BruteForceMatcher<L2<float> > 在这里面！！！！！！！！
int main()
{
    Mat img_1 = imread("D:\\workplace\\opencv_training\\mytrainings\\mytest7\\test1.png");
    Mat img_2 = imread("D:\\workplace\\opencv_training\\mytrainings\\mytest7\\test2.png");
    if (!img_1.data || !img_2.data)
    {
        cout << "error reading images " << endl;
        return -1;
    }

    ORB orb;//以ORB特征检测算法为例
    vector<KeyPoint> keyPoints_1, keyPoints_2;
    Mat descriptors_1, descriptors_2;

    orb(img_1, Mat(), keyPoints_1, descriptors_1);
    orb(img_2, Mat(), keyPoints_2, descriptors_2);
    cout << "img1特征点个数:" << keyPoints_1.size() << " points  img2特征点个数:" << keyPoints_2.size()
        << " points" << endl << ">" << endl;
    Mat img_keypoints1, img_keypoints2;
    drawKeypoints(img_1, keyPoints_1, img_keypoints1, Scalar::all(-1), 0);
    drawKeypoints(img_2, keyPoints_2, img_keypoints2, Scalar::all(-1), 0);
    imshow("test1", img_keypoints1);
    imshow("test2", img_keypoints2);
    BruteForceMatcher<L2<float> >  matcher;
    vector<DMatch> matches;
    matcher.match(descriptors_1, descriptors_2, matches);

    /*
    SIFT sift;
    sift(img_1, Mat(), keyPoints_1, descriptors_1);
    sift(img_2, Mat(), keyPoints_2, descriptors_2);
    BruteForceMatcher<L2<float> >  matcher;
    */

    /*
    SURF surf;
    surf(img_1, Mat(), keyPoints_1);
    surf(img_2, Mat(), keyPoints_2);
    SurfDescriptorExtractor extrator;
    extrator.compute(img_1, keyPoints_1, descriptors_1);
    extrator.compute(img_2, keyPoints_2, descriptors_2);
    BruteForceMatcher<L2<float> >  matcher;
    */

    double max_dist = 0; double min_dist = 100;
    //-- Quick calculation of max and min distances between keypoints     
    for (int i = 0; i < descriptors_1.rows; i++)
    {
        double dist = matches[i].distance;
        if (dist < min_dist) min_dist = dist;
        if (dist > max_dist) max_dist = dist;
    }
    printf("-- Max dist : %f \n", max_dist);
    printf("-- Min dist : %f \n", min_dist);
    //-- Draw only "good" matches (i.e. whose distance is less than 0.6*max_dist )     
    //-- PS.- radiusMatch can also be used here.     
    std::vector< DMatch > good_matches;
    for (int i = 0; i < descriptors_1.rows; i++)
    {
        if (matches[i].distance < 0.6*max_dist)
        {
            good_matches.push_back(matches[i]);
        }
    }

    Mat img_matches;
    drawMatches(img_1, keyPoints_1, img_2, keyPoints_2,
        good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),
        vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
    imshow("Match1", img_matches);
    waitKey();
    //*************************************************************
    // localize the object     
    std::vector<Point2f> obj;
    std::vector<Point2f> scene;

    for (size_t i = 0; i < good_matches.size(); ++i)
    {
        // get the keypoints from the good matches     
        obj.push_back(keyPoints_1[good_matches[i].queryIdx].pt);
        scene.push_back(keyPoints_2[good_matches[i].trainIdx].pt);
    }
    Mat H = findHomography(obj, scene, CV_RANSAC);

    // get the corners from the image_1     
    std::vector<Point2f> obj_corners(4);
    obj_corners[0] = cvPoint(0, 0);
    obj_corners[1] = cvPoint(img_1.cols, 0);
    obj_corners[2] = cvPoint(img_1.cols, img_1.rows);
    obj_corners[3] = cvPoint(0, img_1.rows);
    std::vector<Point2f> scene_corners(4);

    perspectiveTransform(obj_corners, scene_corners, H);

    // draw lines between the corners (the mapped object in the scene - image_2)     
    line(img_matches, scene_corners[0] + Point2f(img_1.cols, 0), scene_corners[1] + Point2f(img_1.cols, 0), Scalar(0, 255, 0));
    line(img_matches, scene_corners[1] + Point2f(img_1.cols, 0), scene_corners[2] + Point2f(img_1.cols, 0), Scalar(0, 255, 0));
    line(img_matches, scene_corners[2] + Point2f(img_1.cols, 0), scene_corners[3] + Point2f(img_1.cols, 0), Scalar(0, 255, 0));
    line(img_matches, scene_corners[3] + Point2f(img_1.cols, 0), scene_corners[0] + Point2f(img_1.cols, 0), Scalar(0, 255, 0));
    imshow("被标记的Match2", img_matches);
    waitKey(0);



}

//-----------------------------------OpenCV学习20------------------------------------- 
//  程序名称:测试自动生成图片名序列并保存视频图像图像
//  2016年10月 Created by孙立波（Visual Studio 2013+OpenCV2.4.9）
#include <opencv2\opencv.hpp> 
#include <opencv2\opencv.hpp> 
#include <iostream>
#include <string> 
#include <stdio.h>  
using namespace cv;
using namespace std;

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

    CvCapture* capture = cvCaptureFromAVI("D:\\workplace\\opencv_training\\bike.avi");
    //打开摄像机用CvCapture* capture = cvCreateCameraCapture(-1); //或者VideoCapture capture(0);capture>>img  
    int i = 0;
    IplImage* img = 0;
    char image_name[100];
    cvNamedWindow("抽取视频窗口");
    //读取和显示  
    while (1)
    {
        img = cvQueryFrame(capture); //获取一帧图片  
        if (img == NULL)
            break;

        cvShowImage("抽取视频窗口", img); //将其显示  
        char key = cvWaitKey(25);
        if (i == 10)
            break;
        //注：一个..\\代表上一级目录！！！！！！！！！！！！！！！！！！！
        sprintf(image_name, "%s%d%s", "D：..\\mytest", ++i, ".jpg");//保存的图片名，即jpg文件保存在上一级目录  
        cvSaveImage(image_name, img);   //保存一帧图片  
    }

    cvReleaseCapture(&capture);
    cvDestroyWindow("抽取视频窗口");

    return 0;
}



//int main()
//{
下面两种方法都可以打开视频
//VideoCapture capture("..//..//1.avi");
///*2、VideoCapture capture;
//capture.open("..//..//1.avi");*/
//if (!capture.isOpened())
//  return 1;
//double rate = capture.get(CV_CAP_PROP_FPS);
//bool stop(false);
//Mat frame;
//namedWindow("Extracted Frame");
这个delay的单位是ms，若是秒，则delay为1/rate。  
rate为每秒播放的帧数  
//int delay = 1000 / rate;
用于设置直接播放哪一帧  
//double position = 0.0;
//capture.set(CV_CAP_PROP_POS_FRAMES, position);
//  while (!stop)
//  {
//      //以下三种方法都可以读取视频  
//      if (!capture.read(frame))
//          break;
//      /*2、capture>>frame;*/
//      /*3、capture.grab();
//      capture.retrieve(frame);*/
//      imshow("Extracted Frame", frame);
//          if (waitKey(delay) >= 0)
//          stop = true;
//          //当delay==0时，将会暂停在该帧，不再执行下去,若不是0，则会等待键盘的消息输入，则结束
//  }
//  //关闭视频文件，但是不是必须的，VideoCapture构造函数会默认调用它  
// capture.release();
//}



//-----------------------------------OpenCV学习21------------------------------------- 
//  程序名称:用OpenCV2的类关于视频的操作！！！！
//  2016年10月 Created by孙立波（Visual Studio 2013+OpenCV2.4.9）
#include <opencv2/core/core.hpp>  
#include <opencv2/highgui/highgui.hpp>  
#include <opencv2/imgproc/imgproc.hpp>  
#include <iostream>  

using namespace std;
using namespace cv;

int main()
{
    //打开视频文件：其实就是建立一个VideoCapture结构  
    VideoCapture capture("D:\\workplace\\opencv_training\\1.avi");
    //检测是否正常打开:成功打开时，isOpened返回ture  
    if (!capture.isOpened())
        cout << "fail to open!" << endl;
    //获取整个帧数  
    long totalFrameNumber = capture.get(CV_CAP_PROP_FRAME_COUNT);
    cout << "整个视频共" << totalFrameNumber << "帧" << endl;


    //设置开始帧()  
    long frameToStart = 300;
    capture.set(CV_CAP_PROP_POS_FRAMES, frameToStart);
    cout << "从第" << frameToStart << "帧开始读" << endl;


    //设置结束帧  
    int frameToStop = 400;

    if (frameToStop < frameToStart)
    {
        cout << "结束帧小于开始帧，程序错误，即将退出！" << endl;
        return -1;
    }
    else
    {
        cout << "结束帧为：第" << frameToStop << "帧" << endl;
    }


    //获取帧率  
    double rate = capture.get(CV_CAP_PROP_FPS);
    cout << "帧率为:" << rate << endl;



    //定义一个用来控制读取视频循环结束的变量  
    bool stop = false;
    //承载每一帧的图像  
    Mat frame;
    //显示每一帧的窗口  
    namedWindow("Extracted frame");
    //两帧间的间隔时间:  
    //int delay = 1000/rate;  
    int delay = 1000 / rate;


    //利用while循环读取帧  
    //currentFrame是在循环体中控制读取到指定的帧后循环结束的变量  
    long currentFrame = frameToStart;


    //滤波器的核  
    int kernel_size = 3;
    Mat kernel = Mat::ones(kernel_size, kernel_size, CV_32F) / (float)(kernel_size*kernel_size);

    while (!stop)
    {
        //读取下一帧  
        if (!capture.read(frame))
        {
            cout << "读取视频失败" << endl;
            return -1;
        }

        //这里加滤波程序  
        imshow("Extracted frame", frame);
        filter2D(frame, frame, -1, kernel);

        imshow("after filter", frame);
        cout << "正在读取第" << currentFrame << "帧" << endl;
        //waitKey(int delay=0)当delay ≤ 0时会永远等待；当delay>0时会等待delay毫秒  
        //当时间结束前没有按键按下时，返回值为-1；否则返回按键  


        int c = waitKey(delay);
        //按下ESC或者到达指定的结束帧后退出读取视频  
        if ((char)c == 27 || currentFrame > frameToStop)
        {
            stop = true;
        }
        //按下按键后会停留在当前帧，等待下一次按键  
        if (c >= 0)
        {
            waitKey(0);
        }
        currentFrame++;

    }
    //关闭视频文件  
    capture.release();
    waitKey(0);
    return 0;
}

//-----------------------------------OpenCV学习22------------------------------------- 
//  程序名称:测试天敏VC400采集卡程序,该程序适用于笔记本自带摄像头视频采集
//  2016年10月 Created by孙立波（Visual Studio 2013+OpenCV2.4.9）
#include <opencv2\opencv.hpp> 
#include <iostream>
#include <string> 

#include "videoInput.h"

using namespace std;
using namespace cv;
void main()
{
    //创建捕获对象
    videoInput VI;
    //可用摄像头,返回ID号的各路总个数，在此直接用0，因为采集卡插在0号ID
    int numID = VI.listDevices();

    int device1 = 0;
    //默认参数设置摄像头
    VI.setupDevice(device1, 640, 480, 1);//1代表采用混合路VI_COMPOSITE连接方式
    /*VI.setupDevice(device1);*/
    //VI.setFormat(device1, VI_PAL_B);  //可设置视频格式，默认下为PAL
    //长宽尺寸
    int width = VI.getWidth(device1);
    int height = VI.getHeight(device1);
    int size = VI.getSize(device1);
    cout << "width=" << width << "\t" << "height=" << height << endl;
    cout << "framesize=" << size << endl;

    //声明显示图像
    Mat image;
    Mat frame;
    image.create(Size(width, height), CV_8UC3);
    frame.create(Size(width, height), CV_8UC3);

    //分配内存
    uchar* yourBuffer = (uchar*)malloc(size);

    while (1)
    {
        VI.getPixels(device1, yourBuffer, false, false);
        image.data = (uchar*)yourBuffer;

        //左右翻转
        flip(image, image, 0);//0竖直翻转1水平翻转-1垂直水平翻转
        waitKey(50);
        imshow("采集的图像", image);

    }

}


//-----------------------------------OpenCV学习23-标定焊接图像------------------------------------- 
//  程序名称:OpenCV标定焊接图像，该程序根据DOS提示，一步步实现标定的自动化，求取内参,
//           标定请在F盘创建“biaoding”用于储存采集的图像和结果
//  过程描述:提取图像并保存，提取各图像序列角点，角点亚像素精确化，摄像机标定畸变参数和内参，
//           定标结果评价（保存结果在F:\\biaoding\\biaoding_result.txt），最后矫正所有图像到“F:\\biaoding”文件夹
//  需设参数:需要提取的的图像数imageCount = **，每个标定板图像角点数board_size = Size(*, *)，每个格子像素边长Size square_size = Size(80, 80)这个参数设置为每个格子边长像素值;  

//******************************************************注意事项**********************************
/*
    注意：
    要想让程序跑完完成整个过程，必须把board_size设对，且程序正以假设得到的都是完全的包含所有角点的图像，所以采集的图像需包含所有格子！！！因为这点调了半天程序
*/
//  所用IDE版本：        Visual Studio 2013    
//  开发所用OpenCV版本：        2.4.9    
//  2016年10月 Created by 孙立波    

//包含程序所依赖的头文件:为方便起见把经常用的头文件都写在这里（前三必须包含），也可以用#include "opencv.hpp"包含下面所有头文件
#include <opencv2\opencv.hpp>   
#include <iostream>
#include <string> 
#include <vector>
#include <iomanip>
#include <fstream>

#include "videoInput.h"
using namespace cv;
using namespace std;
//隐藏控制台窗口
//#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")
int main()
{
    //********************************************************************************************
    //创建捕获对象
    videoInput VI;
    //可用摄像头,返回ID号的各路总个数，在此直接用0，因为采集卡插在0号ID
    int numID = VI.listDevices();

    int device1 = 0;
    //默认参数设置摄像头
    VI.setupDevice(device1, 640, 480, 1);//1代表采用混合路VI_COMPOSITE连接方式,即针对模拟摄像头，视频一路传送的为亮度信号和两个色差信号的混合信号
    /*VI.setupDevice(device1);*/
    //VI.setFormat(device1, VI_PAL_B);  //可设置视频格式，默认下为PAL
    //长宽尺寸
    int width = VI.getWidth(device1);
    int height = VI.getHeight(device1);
    int size = VI.getSize(device1);
    cout << "width=" << width << "\t" << "height=" << height << endl;
    cout << "framesize=" << size << endl;

    //声明显示图像
    Mat frame;

    frame.create(Size(width, height), CV_8UC3);

    //分配内存
    uchar* yourBuffer = (uchar*)malloc(size);

    /************************************************************************
    读取21张图像，存入内存F:\biaoding文件中
    *************************************************************************/
    cout << "开始提取21张标定板图像………………" << endl;
    int imageCount = 21;
    int key = 0;
    int count1 = 0;
    for (int i = 0; i != imageCount; i++)
    {
        cout << "Frame#" << i + 1 << "..." << endl;
        std::stringstream StrStm;
        //为了将i转化为字符型，用StrStm做中介
        string imageFileName;
        StrStm << i + 1;
        StrStm >> imageFileName;
        imageFileName += ".jpg";

        //system("pause");//用waitKey必须有GUI窗口生成才行

        cout << "按Enter开始抽取图像，进入后可按q或者ESC键重新抽取图像，若按Enter键表明这帧图像被存入文件夹中" << endl;
        //key = waitKey();


        int flag = 1;
        while (flag)
        {
            VI.getPixels(device1, yourBuffer, false, false);
            frame.data = (uchar*)yourBuffer;
            waitKey(50);
            //左右翻转
            flip(frame, frame, 0);//0竖直翻转1水平翻转，-1垂直水平翻转

            Mat image0 = frame;//抽取到的临时图像数据并显示出来

            imshow("显示抓取图像", image0);//显示是否符合要求
            int key2;
            key2 = waitKey();
            if (key2 == 13)//按Enter键存取图像到F盘biaoding文件区
            {
                cout << "提取标定板图像成功！………………" << endl;
                std::stringstream str;
                str << "F:\\biaoding\\img" << std::setw(2) << std::setfill('0') << i + 1 << ".jpg";
                std::cout << "提取的图像保存路径及文件名" << str.str() << endl;
                imwrite(str.str(), image0);//保存的是从硬件得到的源格式图像
                flag = 0;
                count1 += 1;//已经得到的标定图像计数总数
            }
            else
            if (key2 == 113 || key2 == 27)//按Q或者ESC键从新获取一阵图像
                cout << "这次提取的标定板图像不成功！重新提取！！！！………………" << endl;
        };//分号很重要！！！！！！

    }
    if (count1 == imageCount)
    {
        cout << "***********************………………" << endl;
        cout << "***********************………………" << endl;
        cout << "下面开始标定图像...................." << endl;
        count1 = 0;
    }

    system("pause");//用waitKey必须有GUI窗口生成才行
    /************************************************************************
    读取每一幅图像，从中提取出角点，然后对角点进行亚像素精确化
    *************************************************************************/

    cout << "开始提取角点………………" << endl;

    cout << "开始提取角点………………" << endl;

    double time0 = static_cast<double>(getTickCount());//记录定标参数求取和将所有图像矫正用的总时间
    ofstream fout("F:\\biaoding\\biaoding_result.txt");  /**    保存定标结果的文件     **/
    Size image_size;                          /****    图像的尺寸      ****/
    Size board_size(9, 9);                    /****    定标板上每行、列的角点数       ****/
    vector<Point2f> corners;                  /****    缓存每幅图像上检测到的角点     ****/
    vector<vector<Point2f>>  corners_Seq;     /****    保存检测到的所有角点           ****/
    vector<Mat>  image_Seq;

    int count = 0;
    int image_count = imageCount;
    for (int i = 0; i != image_count; i++)
    {
        cout << "Frame #" << i + 1 << "..." << endl;
        std::stringstream str;
        //str << "F:\\biaoding\\img" << std::setw(2) << std::setfill('0') << i + 1 << ".jpg";
        str << "F:\\biaoding\\img" << std::setw(2) << std::setfill('0') << i + 1 << ".jpg";
        std::cout << str.str() << std::endl;
        Mat image = imread(str.str());
        image_size = image.size();

        /* 提取角点 */
        Mat imageGray;
        cvtColor(image, imageGray, CV_RGB2GRAY);
        bool patternfound = findChessboardCorners(image, board_size, corners, CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE +
            CALIB_CB_FAST_CHECK);
        if (!patternfound)
        {
            cout << "can not find chessboard corners!\n";
            continue;
            exit(1);
        }
        else
        {
            /*
            亚像素精确化 :迭代过程的终止条件可以是最大迭代次数CV_TERMCRIT_ITER类型，或者是设定的精度CV_TERMCRIT_EPS类型(或者是两
            者的组合)。终止条件的设置在极大程度上影响最终得到的亚像素值的精度。在此，指定为0.10，则求得的亚像素级精度为像素的十分
            之一
            */
            cornerSubPix(imageGray, corners, Size(11, 11), Size(-1, -1), TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
            //Size(11, 11)为搜索窗口的一半尺寸，Size(-1, -1)死区的一半尺寸，死区为不对搜索区的中央位置做求和运算的区域。/
            //它是用来避免自相关矩阵出现的某些可能的奇异性。当值为（-1，-1）表示没有死区。
            //TermCriteria为求角点的迭代过程的终止条件。即角点位置的确定，要么迭代数大于某个设定值，或者是精确懂达到某个设定值。
            //criteria可以是最大迭代数目，或者是设定的精确度，也可以是它们的组合。
            /* 绘制检测到的角点并保存 */
            Mat imageTemp = image.clone();
            for (int j = 0; j < corners.size(); j++)
            {
                circle(imageTemp, corners[j], 10, Scalar(0, 0, 255), 2, 8, 0);
            }
            string imageFileName;
            std::stringstream StrStm;
            StrStm << i + 1;
            StrStm >> imageFileName;
            imageFileName += "_corner.jpg";
            //保存提取角点的图像
            imwrite("F:\\biaoding\\" + imageFileName, imageTemp);
            cout << "Frame corner#" << i + 1 << "...end" << endl;

            count = count + corners.size();
            //将该角点压入角点序列堆栈
            corners_Seq.push_back(corners);
        }
        //将处理过的图像压入源图像堆栈
        image_Seq.push_back(image);
    }
    cout << "角点提取完成！\n";

    cout << "角点提取完成！下一步摄像机定标\n";
    system("pause");
    /************************************************************************
    摄像机定标
    *************************************************************************/
    cout << "开始定标………………" << endl;
    Size square_size = Size(80, 80);                                      /**** 实际测量得到的定标板上每个棋盘格的大小，单位为像素 ****/
    vector<vector<Point3f>>  object_Points;                       /**** 保存定标板上角点的三维坐标   ****/


    Mat image_points = Mat(1, count, CV_32FC2, Scalar::all(0));   /***** 保存提取的所有角点1*序列图像的角点总数   *****/
    vector<int>  point_counts;                                    /***** 每幅图像中角点的数量 ****/
    Mat intrinsic_matrix = Mat(3, 3, CV_32FC1, Scalar::all(0));  /***** 摄像机内参数矩阵    ****/
    Mat distortion_coeffs = Mat(1, 4, CV_32FC1, Scalar::all(0));  /* 摄像机的4个畸变系数：k1,k2,p1,p2 */
    vector<cv::Mat> rotation_vectors;                             /* 图像序列图像的旋转向量，每一行代表一个旋转向量 */
    vector<cv::Mat> translation_vectors;                         /* 每幅图像的平移向量，每一行代表一个平移向量 */

    /* 初始化定标板上角点的三维坐标，此用的是像素坐标 */
    for (int t = 0; t<image_count; t++)
    {
        vector<Point3f> tempPointSet;//存储每幅图像的像素坐标
        for (int i = 0; i<board_size.height; i++)
        {
            for (int j = 0; j<board_size.width; j++)
            {
                /* 假设定标板放在世界坐标系中z=0的平面上 */
                Point3f tempPoint;
                //在这里，board_size中棋盘格子为单位长度，当square_size存储的像素边长为边长为80，代表width、height为80
                tempPoint.x = i*square_size.width;
                tempPoint.y = j*square_size.height;
                tempPoint.z = 0;
                tempPointSet.push_back(tempPoint);
            }
        }
        object_Points.push_back(tempPointSet);//存储图像序列中每幅图像的像素坐标
    }

    /* 初始化每幅图像中的角点数量，这里我们假设每幅图像中都可以看到完整的定标板 */
    for (int i = 0; i< image_count; i++)
    {
        point_counts.push_back(board_size.width*board_size.height);
    }

    /* 开始定标 */
    calibrateCamera(object_Points, corners_Seq, image_size, intrinsic_matrix, distortion_coeffs, rotation_vectors, translation_vectors, 0);
    cout << "定标完成！\n";
    /************************************************************************
    对定标结果进行评价
    *************************************************************************/
    cout << "开始评价定标结果………………" << endl;
    double total_err = 0.0;                   /* 所有图像的平均误差的总和 */
    double err = 0.0;                        /* 每幅图像的平均误差 */
    vector<Point2f>  image_points2;             /****   保存重新计算得到的投影点    ****/

    cout << "每幅图像的定标误差：" << endl;
    fout << "每幅图像的定标误差：" << endl << endl;
    for (int i = 0; i<image_count; i++)
    {
        vector<Point3f> tempPointSet = object_Points[i];
        /****    通过得到的摄像机内外参数，对空间的三维点进行重新投影计算，得到新的投影点     ****/
        projectPoints(tempPointSet, rotation_vectors[i], translation_vectors[i], intrinsic_matrix, distortion_coeffs, image_points2);
        /* 计算新的投影点和旧的投影点之间的误差*/
        vector<Point2f> tempImagePoint = corners_Seq[i];
        Mat tempImagePointMat = Mat(1, tempImagePoint.size(), CV_32FC2);
        Mat image_points2Mat = Mat(1, image_points2.size(), CV_32FC2);
        for (size_t i = 0; i != tempImagePoint.size(); i++)
        {
            image_points2Mat.at<Vec2f>(0, i) = Vec2f(image_points2[i].x, image_points2[i].y);
            tempImagePointMat.at<Vec2f>(0, i) = Vec2f(tempImagePoint[i].x, tempImagePoint[i].y);
        }
        err = norm(image_points2Mat, tempImagePointMat, NORM_L2);
        total_err += err /= point_counts[i];
        cout << "第" << i + 1 << "幅图像的平均误差：" << err << "像素" << endl;
        fout << "第" << i + 1 << "幅图像的平均误差：" << err << "像素" << endl;
    }
    cout << "总体平均误差：" << total_err / image_count << "像素" << endl;
    fout << "总体平均误差：" << total_err / image_count << "像素" << endl << endl;
    cout << "评价完成！" << endl;

    /************************************************************************
    保存定标结果
    *************************************************************************/
    cout << "开始保存定标结果………………" << endl;
    Mat rotation_matrix = Mat(3, 3, CV_32FC1, Scalar::all(0)); /* 保存每幅图像的旋转矩阵 */

    fout << "相机内参数矩阵：" << endl;
    cout << "相机内参数矩阵：" << endl;
    fout << intrinsic_matrix << endl;
    cout << intrinsic_matrix << endl;
    fout << "畸变系数：\n";
    cout << "畸变系数：\n";
    fout << distortion_coeffs << endl;
    cout << distortion_coeffs << endl;
    for (int i = 0; i<image_count; i++)
    {
        fout << "第" << i + 1 << "幅图像的旋转向量：" << endl;
        fout << rotation_vectors[i] << endl;

        /* 将旋转向量转换为相对应的旋转矩阵 */
        Rodrigues(rotation_vectors[i], rotation_matrix);
        fout << "第" << i + 1 << "幅图像的旋转矩阵：" << endl;
        fout << rotation_matrix << endl;
        fout << "第" << i + 1 << "幅图像的平移向量：" << endl;
        fout << translation_vectors[i] << endl;
    }
    cout << "完成保存" << endl;
    fout << endl;


    /************************************************************************
    显示定标结果
    *************************************************************************/
    Mat mapx = Mat(image_size, CV_32FC1);
    Mat mapy = Mat(image_size, CV_32FC1);
    Mat R = Mat::eye(3, 3, CV_32F);
    cout << "保存矫正图像" << endl;
    for (int i = 0; i != image_count; i++)
    {
        cout << "Frame #" << i + 1 << "..." << endl;
        //newCameraMatrix——输入的校正后的3X3摄像机矩阵（也可用cvStereoRectify()得出的3X4的左或右投影矩阵，其实系统会自动提取该
        //矩阵前三列的有用部分作为输入参数）注：！！无校正变换的相机仍用求得内参矩阵
        Mat newCameraMatrix = Mat(3, 3, CV_32FC1, Scalar::all(0));
        //得到映射关系:R——输入的第一和第二相机坐标系之间的旋转矩阵,一般般无校正变换的相机，默认为单位矩阵
        // opencv中，remap与undistortion都是消除畸变的函数，undistortion在设置了一些参数后调用了remap函数，二者的算法实质是一样
        //的。由目标图像的坐标，找到对应的原始图像坐标，然后将其值复制到目标图像。大致思路是如此，由于图像大小和变换，需要插值或
        //近似的方法，如最邻近法、线性插值等
        initUndistortRectifyMap(intrinsic_matrix, distortion_coeffs, R, intrinsic_matrix, image_size, CV_32FC1, mapx, mapy);
        Mat t = image_Seq[i].clone();
        cv::remap(image_Seq[i], t, mapx, mapy, INTER_LINEAR);
        string imageFileName;
        std::stringstream StrStm;
        StrStm << i + 1;
        StrStm >> imageFileName;
        imageFileName += "_校正图像.jpg";
        imwrite("F:\\biaoding\\" + imageFileName, t);
    }
    cout << "保存结束" << endl;

    time0 = ((double)getTickCount() - time0) / getTickFrequency();
    cout << "标定用时:" << time0 << "秒" << endl;
    system("pause");

    /************************************************************************
    测试一张图片,用标定过参数去校正畸变，并记所用时间
    *************************************************************************/
    /*
    double time1 = static_cast<double>(getTickCount());
    if (1)
    {
    cout << "TestImage ..." << endl;
    //newCameraMatrix——输入的校正后的3X3摄像机矩阵（也可用cvStereoRectify()得出的3X4的左或右投影矩阵，其实系统会自动提取该
    //矩阵前三列的有用部分作为输入参数）
    Mat newCameraMatrix = Mat(3, 3, CV_32FC1, Scalar::all(0));
    Mat testImage = imread("F:\\biaoding\\img03.jpg", 1);
    initUndistortRectifyMap(intrinsic_matrix, distortion_coeffs, R, intrinsic_matrix, image_size, CV_32FC1, mapx, mapy);
    Mat t = testImage.clone();
    cv::remap(testImage, t, mapx, mapy, INTER_LINEAR);

    imwrite("img3_TestOutput.jpg", t);
    cout << "保存结束" << endl;
    }
    time1 = ((double)getTickCount() - time1) / getTickFrequency();
    cout << "一张图片的畸变校正用时:" << time1 << "秒" << endl;
    */
    return 0;
}