3d 如何使用OpenCV cvProjectPoints2函数

我在cvProjectPoints2函数方面遇到了一些问题。 以下是O'Reilly的《学习OpenCV》一书中的功能概述：

第一个参数，

object\u points

，是要投影的点列表；它只是一个包含点位置的N×3矩阵。您可以在对象自身的局部坐标系中给出这些矩阵，然后提供3×1矩阵

旋转_向量

*和

平移_向量

，以关联两个坐标。如果在您的特定环境中更容易直接在相机坐标中工作，那么您可以在该系统中给出

对象点

，并将

旋转向量

和

平移向量

设置为包含0。†

固有_矩阵

和

畸变系数

只是第章中讨论的摄像机固有信息和来自cvCalibrateCamera2（）的畸变系数 11

image\u points

参数是一个N×2矩阵，计算结果将写入其中

首先，似乎存在

object\u points

array的bug。如果只有一个点，即N=1，则程序崩溃。 总之，我有几个相机的内在参数和投影矩阵。失真系数为0，即不存在失真。 为简单起见，假设我有两个摄像头：

double intrinsic[2][3][3] = {
//camera 0
1884.190000,    0, 513.700000,
0.0,    1887.490000,    395.609000,
0.0,    0.0,    1.0,
//camera 4
1877.360000,    0.415492,   579.467000,
0.0,    1882.430000,    409.612000,
0.0,    0.0,    1.0
};

double projection[2][3][4] = {
//camera 0
0.962107,   -0.005824,  0.272486,   -14.832727,
0.004023,   0.999964,   0.007166,   0.093097,
-0.272519,  -0.005795,  0.962095,   -0.005195,
//camera 4
1.000000,   0.000000,   -0.000000,  0.000006,
0.000000,   1.000000,   -0.000000,  0.000001,
-0.000000,  -0.000000,  1.000000,   -0.000003
};

据我所知，该信息足以在任何相机视图上投影任何点（x、y、z）。这里，在x、y、z坐标中，摄像机4的光学中心是世界坐标的原点

这是我的密码：

#include <cv.h>
#include <highgui.h>
#include <cvaux.h>
#include <cxcore.h>
#include <stdio.h>

double intrinsic[2][3][3] = {
//0
1884.190000,    0, 513.700000,
0.0,    1887.490000,    395.609000,
0.0,    0.0,    1.0,
//4
1877.360000,    0.415492,   579.467000,
0.0,    1882.430000,    409.612000,
0.0,    0.0,    1.0
};

double projection[2][3][4] = {
//0
0.962107,   -0.005824,  0.272486,   -14.832727,
0.004023,   0.999964,   0.007166,   0.093097,
-0.272519,  -0.005795,  0.962095,   -0.005195,
//4
1.000000,   0.000000,   -0.000000,  0.000006,
0.000000,   1.000000,   -0.000000,  0.000001,
-0.000000,  -0.000000,  1.000000,   -0.000003
};


int main() {
    CvMat* camera_matrix[2]; //
    CvMat* rotation_matrix[2]; //
    CvMat* dist_coeffs[2]; 
    CvMat* translation[2];
    IplImage* image[2];
    image[0] = cvLoadImage("color-cam0-f000.bmp", 1);
    image[1] = cvLoadImage("color-cam4-f000.bmp", 1);
    CvSize image_size;
    image_size = cvSize(image[0]->width, image[0]->height);

    for (int m=0; m<2; m++) {
        camera_matrix[m] = cvCreateMat(3, 3, CV_32F);
        dist_coeffs[m] = cvCreateMat(1, 4, CV_32F);
        rotation_matrix[m] = cvCreateMat(3, 3, CV_32F);
        translation[m] = cvCreateMat(3, 1, CV_32F);
    }

    for (int m=0; m<2; m++) {
        for (int i=0; i<3; i++)
            for (int j=0; j<3; j++) {
                cvmSet(camera_matrix[m],i,j, intrinsic[m][i][j]);
                cvmSet(rotation_matrix[m],i,j, projection[m][i][j]);
            }
        for (int i=0; i<4; i++)
            cvmSet(dist_coeffs[m], 0, i, 0);
        for (int i=0; i<3; i++)
            cvmSet(translation[m], i, 0, projection[m][i][3]);
    }

    CvMat* vector = cvCreateMat(3, 1, CV_32F);
    CvMat* object_points = cvCreateMat(10, 3, CV_32F);
    cvmSet(object_points, 0, 0, 1000);
    cvmSet(object_points, 0, 1, 500);
    cvmSet(object_points, 0, 2, 100);

    CvMat* image_points = cvCreateMat(10, 2, CV_32F);
    int m = 0;
    cvRodrigues2(rotation_matrix[m], vector);
    cvProjectPoints2(object_points, vector, translation[m], camera_matrix[m], dist_coeffs[m], image_points);
    printf("%f\n", cvmGet(image_points, 0, 0));
    printf("%f\n", cvmGet(image_points, 0, 1));
    return 0;
}

#包括
#包括
#包括
#包括
#包括
双内禀[2][3][3]={
//0
1884.190000,    0, 513.700000,
0.0,    1887.490000,    395.609000,
0.0,    0.0,    1.0,
//4
1877.360000,    0.415492,   579.467000,
0.0,    1882.430000,    409.612000,
0.0,    0.0,    1.0
};
双投影[2][3][4]={
//0
0.962107,   -0.005824,  0.272486,   -14.832727,
0.004023,   0.999964,   0.007166,   0.093097,
-0.272519,  -0.005795,  0.962095,   -0.005195,
//4
1.000000,   0.000000,   -0.000000,  0.000006,
0.000000,   1.000000,   -0.000000,  0.000001,
-0.000000,  -0.000000,  1.000000,   -0.000003
};
int main（）{
CvMat*摄像机矩阵[2]//
CvMat*旋转矩阵[2]//
CvMat*距离系数[2]；
CvMat*翻译[2]；
IplImage*图像[2]；
image[0]=cvLoadImage（“color-cam0-f000.bmp”，1）；
图像[1]=cvLoadImage（“color-cam4-f000.bmp”，1）；
CvSize图像大小；
图像大小=cvSize（图像[0]->宽度，图像[0]->高度）；
对于（int m=0；mYeah），cvProjectPoints用于投影点阵列。您可以通过简单的矩阵运算投影一个点：

CvMat *pt = cvCreateMat(3, 1, CV_32FC1);
CvMat *pt_rt = cvCreateMat(3, 1, CV_32FC1);
CvMat *proj_pt = cvCreateMat(3, 1, CV_32FC1);
cvMatMulAdd(rotMat, pt, translation, pt_rt);
cvMatMul(intrinsic, pt_rt, proj_pt);
// convertPointsHomogenious might be used
float scale = (float)CV_MAT_ELEM(*proj_pt, float, 2, 0); 
float x = CV_MAT_ELEM(*proj_pt, float, 0, 0) / scale;
float y = CV_MAT_ELEM(*proj_pt, float, 1, 0) / scale;
CvPoint2D32f img_pt = cvPoint2D32f(x, y);

我没有太多的时间看你的代码，但是相机4的相机内在矩阵中的0.415492因子是什么？我希望是0.0。
CvMat *pt = cvCreateMat(3, 1, CV_32FC1);
CvMat *pt_rt = cvCreateMat(3, 1, CV_32FC1);
CvMat *proj_pt = cvCreateMat(3, 1, CV_32FC1);
cvMatMulAdd(rotMat, pt, translation, pt_rt);
cvMatMul(intrinsic, pt_rt, proj_pt);
// convertPointsHomogenious might be used
float scale = (float)CV_MAT_ELEM(*proj_pt, float, 2, 0); 
float x = CV_MAT_ELEM(*proj_pt, float, 0, 0) / scale;
float y = CV_MAT_ELEM(*proj_pt, float, 1, 0) / scale;
CvPoint2D32f img_pt = cvPoint2D32f(x, y);