OpenCV错误-211指定的纵横比不正确，CVC校准（C）

我正在尝试编写一个函数，它使用存储的图像对来校准立体相机。代码是用C写的。我得到了错误消息

OpenCV错误：CVCalibleCamera2文件/home/daniel/OpenCV/OpenCV-2.4.13/modules/calib3d/src/calibration.cpp第1602行中的一个参数值超出范围（指定的纵横比（=cameraMatrix[0][0]/cameraMatrix[1][1]） 在引发“cv:：Exception”的实例后调用terminate what（）：/home/daniel/opencv/opencv-2.4.13/modules/calib3d/src/calibration.cpp:1602:error:（-211）函数CVcalibleCamera2中指定的纵横比（=cameraMatrix[0][0]/cameraMatrix[1][1]）不正确

这是由调用cvStereoCalibrate引发的，表示我的一个参数初始化/填充不正确。我只是不知道我做错了什么

我使用的宏扩展到以下内容：

内板6

板W__内部9

已保存的图像数17

代码：

int-calibrate\u-camera\u-from\u-saved\u-images（）{
IplImage*左框，*右框；
字符图像名称[20]；
//创建等于N乘以3的objectPoints，N是棋盘上的方块数
//正在使用（BOARD_W*BOARD_H）乘以提供的图像数
CvMat*objectPoints=cvCreateMat(
BOARD_W_INNER*BOARD_H_INNER*已保存的图像数，3，
CV_32FC1）；
//初始化用于校准的objectPoints
整数计数=0；
int i，j，k；
对于（i=0；i效率？
CV_MAT_ELEM（*对象点，浮点，（i*板内）+（j*板内）+k，0）=
方形尺寸*k；
CV_MAT_ELEM（*对象点，浮点，（i*板内）+（j*板内）+k，1）=
正方形尺寸*j；
CV_MAT_ELEM（*对象点，浮点，（i*板内）+（j*板内）+k，2）=0；
}
}
}
CvPoint2D32f*corners1=新的CvPoint2D32f[BOARD_W_INNER*BOARD_H_INNER]；
CvPoint2D32f*corners2=新的CvPoint2D32f[BOARD_W_INNER*BOARD_H_INNER]；
CvMat*imagePoints1=cvCreateMat(
BOARD_W_INNER*BOARD_H_INNER*已保存的图像数，2，
CV_32FC1）；
CvMat*imagePoints2=cvCreateMat(
BOARD_W_INNER*BOARD_H_INNER*已保存的图像数，2，
CV_32FC1）；
CvMat*nPoints=cvCreateMat（NUM_SAVED_IMAGES，1，CV_32SC1）；
//加载图像并找到它们的角点，然后存储角点
对于（i=0；i

编辑：经过进一步测试，我发现使用CV_CALIB_FIX_ASPECT_比率是导致错误的原因。其他标志不会导致此问题。然而，矩阵的输出看起来不起作用

cameraMatrix1.xml：

    <?xml version="1.0"?>
<opencv_storage>
<cameraMatrix1 type_id="opencv-matrix">
  <rows>3</rows>
  <cols>3</cols>
  <dt>d</dt>
  <data>
    .Nan 0. .Nan 0. .Nan .Nan 0. 0. 1.</data></cameraMatrix1>
</opencv_storage>

3.
3.
D
.0。南0。楠，楠0。01.

在尝试了很多不同的东西并将版本从2.4.13切换到2.4.7，然后再切换回来之后，我现在有了一些代码，可以管理拍摄图像、校准相机并将校准值保存到.xml文件中

以下代码用于拍摄我可以找到所有角落的图像：

cvNamedWindow("CameraTestL", CV_WINDOW_AUTOSIZE);
    cvNamedWindow("CameraTestR", CV_WINDOW_AUTOSIZE);
    CvCapture *captureL, *captureR;
    IplImage *frameL, *frameR;

    char imageNameL[20];
    strcpy(imageNameL, "imagel00.png");

    char imageNameR[20];
    strcpy(imageNameR, "imageR00.png");

    int i = 0;

    captureL = cvCreateCameraCapture(1);
    captureR = cvCreateCameraCapture(0);

    //resize capture from standard 640/480 to 320/240 due to USB bandwith constraints
    int res = cvSetCaptureProperty(captureL, CV_CAP_PROP_FRAME_WIDTH,
    FRAME_WIDTH);
    res = cvSetCaptureProperty(captureL, CV_CAP_PROP_FRAME_HEIGHT,
    FRAME_HEIGHT);

    res = cvSetCaptureProperty(captureR, CV_CAP_PROP_FRAME_WIDTH, FRAME_WIDTH);
    res = cvSetCaptureProperty(captureR, CV_CAP_PROP_FRAME_HEIGHT,
    FRAME_HEIGHT);

    assert(captureL != NULL);
    assert(captureR != NULL);

    int cornerCount;

    CvSize boardSize = cvSize(BOARD_W, BOARD_H);

    while (1) {
        frameL = cvQueryFrame(captureL);
        frameR = cvQueryFrame(captureR);
        if (!frameL)
            break;
        if (!frameR)
            break;

        CvPoint2D32f* corners = new CvPoint2D32f[ BOARD_W * BOARD_H];
    //  IplImage *helperL, *helperR;
        IplImage *grayImage = cvCreateImage(cvGetSize(frameL), 8, 1);

    //  cvCopyImage(frameL, helperL);
    //  cvCopyImage(frameR, helperR);

        int found = cvFindChessboardCorners(frameL, boardSize, corners,
                &cornerCount,
                CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FILTER_QUADS);

        cvCvtColor(frameL, grayImage, CV_BGR2GRAY);
        cvFindCornerSubPix(grayImage, corners, cornerCount, cvSize(11,11), cvSize(-1,-1), cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 30, 0.1));

        cvDrawChessboardCorners(frameL, boardSize, corners, cornerCount, found);

        found = cvFindChessboardCorners(frameR, boardSize, corners, &cornerCount, CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FILTER_QUADS);
        cvCvtColor(frameR, grayImage, CV_BGR2GRAY);
        cvFindCornerSubPix(grayImage, corners, cornerCount, cvSize(11,11), cvSize(-1,-1), cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 30, 0.1));

        cvDrawChessboardCorners(frameR, boardSize, corners, cornerCount, found);

        cvShowImage("CameraTestL", frameL);
        cvShowImage("CameraTestR", frameR);
        //cvWaitKey returns value of key pressed
        char c = cvWaitKey(33);
        //press ESC key to break (ESC == 27)
        if (c == 27)
            break;
        if (c == 's') {

            frameL = cvQueryFrame(captureL);
            frameR = cvQueryFrame(captureR);

            sprintf(imageNameL, "imageL0%02u.png", i);
            sprintf(imageNameR, "imageR0%02u.png", i);

            cvSaveImage(imageNameL, frameL, 0);
            cvSaveImage(imageNameR, frameR, 0);

            printf("Saved image #%d\n", i);
            fflush(stdout);
            i++;
        }
    }

    cvReleaseCapture(&captureL);
    cvReleaseCapture(&captureR);
    cvDestroyWindow("CameraTestL");
    cvDestroyWindow("CameraTestR");

    return 0;

下面的代码读取图像并计算CameraMatrix和其他参数

int calibrate_camera_from_saved_images() {
IplImage *leftFrame, *rightFrame;
char imageName[20];

//create objectPoints equal to N-by-3, N being the number of squares on the chess board
//in use (BOARD_W * BOARD_H) times the number of images provided
CvMat *objectPoints = cvCreateMat(
BOARD_W_INNER * BOARD_H_INNER * NUM_SAVED_IMAGES, 3,
CV_32FC1);

//initialize objectPoints for cvStereoCalibrate
int count = 0;
int i, j, k;

for (i = 0; i < NUM_SAVED_IMAGES; i++) {
    for (j = 0; j < BOARD_W_INNER; j++) {
        for (k = 0; k < BOARD_H_INNER; k++, count++) {
            //alternatively use (i*BOARD_W)+(j*BOARD_H)+k instead of count -> efficiency ?

            CV_MAT_ELEM(*objectPoints, float, count, 0 ) =
            SQUARE_SIZE * k;
            CV_MAT_ELEM(*objectPoints, float, count, 1 ) =
            SQUARE_SIZE * j;
            CV_MAT_ELEM(*objectPoints, float, count, 2 ) = 0;
        }
    }
}

CvPoint2D32f *corners1 = new CvPoint2D32f[ BOARD_W_INNER * BOARD_H_INNER];
CvPoint2D32f *corners2 = new CvPoint2D32f[ BOARD_W_INNER * BOARD_H_INNER];

CvMat *imagePoints1 = cvCreateMat(
BOARD_W_INNER * BOARD_H_INNER * NUM_SAVED_IMAGES, 2,
CV_32FC1);
CvMat *imagePoints2 = cvCreateMat(
BOARD_W_INNER * BOARD_H_INNER * NUM_SAVED_IMAGES, 2,
CV_32FC1);

CvMat *nPoints = cvCreateMat(NUM_SAVED_IMAGES, 1, CV_32SC1);
count = 0;
//load images and find their corners, corners are then stored
for (i = 0; i < NUM_SAVED_IMAGES; i++) {
    sprintf(imageName, "imageL%002u.png", i);
    leftFrame = cvLoadImage(imageName);
    find_chess_board(leftFrame, BOARD_W_INNER, BOARD_H_INNER, corners1);
    sprintf(imageName, "imageR%002u.png", i);
    rightFrame = cvLoadImage(imageName);
    find_chess_board(rightFrame, BOARD_W_INNER, BOARD_H_INNER, corners2);

    for (j = 0; j < (BOARD_W_INNER * BOARD_H_INNER); j++, count++) {
        CV_MAT_ELEM( *imagePoints1, float, count, 0 ) = corners1[j].x;
        CV_MAT_ELEM( *imagePoints1, float, count, 1 ) = corners1[j].y;
        CV_MAT_ELEM( *imagePoints2, float, count, 0 ) = corners2[j].x;
        CV_MAT_ELEM( *imagePoints2, float, count, 1 ) = corners2[j].y;
    }

    CV_MAT_ELEM(*nPoints, int, i, 0) = (BOARD_W_INNER * BOARD_H_INNER);
}

static CvMat *cameraMatrix1 = cvCreateMat(3, 3, CV_64F);
static CvMat *distCoeffs1 = cvCreateMat(5, 1, CV_32FC1);

static CvMat *cameraMatrix2 = cvCreateMat(3, 3, CV_64F);
static CvMat *distCoeffs2 = cvCreateMat(5, 1, CV_32FC1);

for (i = 0; i < 3; i++) {
    CV_MAT_ELEM( *cameraMatrix1, float, i, 0) = 1;
    CV_MAT_ELEM( *cameraMatrix1, float, i, 1) = 1;
    CV_MAT_ELEM( *cameraMatrix1, float, i, 2) = 1;
    CV_MAT_ELEM( *cameraMatrix2, float, i, 0) = 1;
    CV_MAT_ELEM( *cameraMatrix2, float, i, 1) = 1;
    CV_MAT_ELEM( *cameraMatrix2, float, i, 2) = 1;
}

static CvSize imageSize = cvGetSize(leftFrame);
static CvMat* R = cvCreateMat(3, 3, CV_64FC1);
static CvMat* T = cvCreateMat(3, 1, CV_64FC1);
static CvMat* E = cvCreateMat(3, 3, CV_64FC1);
static CvMat* F = cvCreateMat(3, 3, CV_64FC1);

printf("Attempting Calibration\n");
fflush(stdout);
cvStereoCalibrate(objectPoints, imagePoints1, imagePoints2, nPoints,
        cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize,
        R, T, E, F,
        cvTermCriteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 100, 1e-5),
        CV_CALIB_SAME_FOCAL_LENGTH);

cvSave("cameraMatrix1.xml", cameraMatrix1);
cvSave("distCoeffs1.xml", distCoeffs1);
cvSave("cameraMatrix2.xml", cameraMatrix2);
cvSave("distCoeffs2.xml", distCoeffs2);
cvSave("RotationMatrix.xml", R);
cvSave("TransformationVector.xml", T);

return 0;

int-calibrate\u-camera\u-from\u-saved\u-images（）{
IplImage*左框，*右框；
字符图像名称[20]；
//创建等于N乘以3的objectPoints，N是棋盘上的方块数
//正在使用（BOARD_W*BOARD_H）乘以提供的图像数
CvMat*objectPoints=cvCreateMat(
BOARD_W_INNER*BOARD_H_INNER*已保存的图像数，3，
CV_32FC1）；
//初始化用于校准的objectPoints
整数计数=0；
int i，j，k；
对于（i=0；iint calibrate_camera_from_saved_images() {
IplImage *leftFrame, *rightFrame;
char imageName[20];

//create objectPoints equal to N-by-3, N being the number of squares on the chess board
//in use (BOARD_W * BOARD_H) times the number of images provided
CvMat *objectPoints = cvCreateMat(
BOARD_W_INNER * BOARD_H_INNER * NUM_SAVED_IMAGES, 3,
CV_32FC1);

//initialize objectPoints for cvStereoCalibrate
int count = 0;
int i, j, k;

for (i = 0; i < NUM_SAVED_IMAGES; i++) {
    for (j = 0; j < BOARD_W_INNER; j++) {
        for (k = 0; k < BOARD_H_INNER; k++, count++) {
            //alternatively use (i*BOARD_W)+(j*BOARD_H)+k instead of count -> efficiency ?

            CV_MAT_ELEM(*objectPoints, float, count, 0 ) =
            SQUARE_SIZE * k;
            CV_MAT_ELEM(*objectPoints, float, count, 1 ) =
            SQUARE_SIZE * j;
            CV_MAT_ELEM(*objectPoints, float, count, 2 ) = 0;
        }
    }
}

CvPoint2D32f *corners1 = new CvPoint2D32f[ BOARD_W_INNER * BOARD_H_INNER];
CvPoint2D32f *corners2 = new CvPoint2D32f[ BOARD_W_INNER * BOARD_H_INNER];

CvMat *imagePoints1 = cvCreateMat(
BOARD_W_INNER * BOARD_H_INNER * NUM_SAVED_IMAGES, 2,
CV_32FC1);
CvMat *imagePoints2 = cvCreateMat(
BOARD_W_INNER * BOARD_H_INNER * NUM_SAVED_IMAGES, 2,
CV_32FC1);

CvMat *nPoints = cvCreateMat(NUM_SAVED_IMAGES, 1, CV_32SC1);
count = 0;
//load images and find their corners, corners are then stored
for (i = 0; i < NUM_SAVED_IMAGES; i++) {
    sprintf(imageName, "imageL%002u.png", i);
    leftFrame = cvLoadImage(imageName);
    find_chess_board(leftFrame, BOARD_W_INNER, BOARD_H_INNER, corners1);
    sprintf(imageName, "imageR%002u.png", i);
    rightFrame = cvLoadImage(imageName);
    find_chess_board(rightFrame, BOARD_W_INNER, BOARD_H_INNER, corners2);

    for (j = 0; j < (BOARD_W_INNER * BOARD_H_INNER); j++, count++) {
        CV_MAT_ELEM( *imagePoints1, float, count, 0 ) = corners1[j].x;
        CV_MAT_ELEM( *imagePoints1, float, count, 1 ) = corners1[j].y;
        CV_MAT_ELEM( *imagePoints2, float, count, 0 ) = corners2[j].x;
        CV_MAT_ELEM( *imagePoints2, float, count, 1 ) = corners2[j].y;
    }

    CV_MAT_ELEM(*nPoints, int, i, 0) = (BOARD_W_INNER * BOARD_H_INNER);
}

static CvMat *cameraMatrix1 = cvCreateMat(3, 3, CV_64F);
static CvMat *distCoeffs1 = cvCreateMat(5, 1, CV_32FC1);

static CvMat *cameraMatrix2 = cvCreateMat(3, 3, CV_64F);
static CvMat *distCoeffs2 = cvCreateMat(5, 1, CV_32FC1);

for (i = 0; i < 3; i++) {
    CV_MAT_ELEM( *cameraMatrix1, float, i, 0) = 1;
    CV_MAT_ELEM( *cameraMatrix1, float, i, 1) = 1;
    CV_MAT_ELEM( *cameraMatrix1, float, i, 2) = 1;
    CV_MAT_ELEM( *cameraMatrix2, float, i, 0) = 1;
    CV_MAT_ELEM( *cameraMatrix2, float, i, 1) = 1;
    CV_MAT_ELEM( *cameraMatrix2, float, i, 2) = 1;
}

static CvSize imageSize = cvGetSize(leftFrame);
static CvMat* R = cvCreateMat(3, 3, CV_64FC1);
static CvMat* T = cvCreateMat(3, 1, CV_64FC1);
static CvMat* E = cvCreateMat(3, 3, CV_64FC1);
static CvMat* F = cvCreateMat(3, 3, CV_64FC1);

printf("Attempting Calibration\n");
fflush(stdout);
cvStereoCalibrate(objectPoints, imagePoints1, imagePoints2, nPoints,
        cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize,
        R, T, E, F,
        cvTermCriteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 100, 1e-5),
        CV_CALIB_SAME_FOCAL_LENGTH);

cvSave("cameraMatrix1.xml", cameraMatrix1);
cvSave("distCoeffs1.xml", distCoeffs1);
cvSave("cameraMatrix2.xml", cameraMatrix2);
cvSave("distCoeffs2.xml", distCoeffs2);
cvSave("RotationMatrix.xml", R);
cvSave("TransformationVector.xml", T);

return 0;