【问题标题】:Calculating essential matrix using OpenCV - what did I do wrong使用 OpenCV 计算基本矩阵 - 我做错了什么
【发布时间】:2021-03-03 02:28:32
【问题描述】:

我目前正在尝试基于我用作“基本相机”的第四个相机来计算 3 个相机的基本矩阵。我正在使用 OpenCV 来计算基本矩阵。

即使我的观点似乎是正确的,但当我重建相机的姿势时,它没有任何意义。例如,两个输出平移向量是 (0, 0, -1)。 我怀疑我以某种方式搞砸了内部约束的执行,但不知道如何。

我不确定我做错了什么,希望有人可以帮助我:)

basePoints = np.loadtxt("data/calibration/fundamental_matrix/resulting_data/camera0/extracted_points/points.txt")

    for c in range(1, cameras):
        print(f"caculating essential matrix for camera {c}")
        cameraPoints = np.loadtxt(f"data/calibration/fundamental_matrix/resulting_data/camera{c}/extracted_points/points.txt")
        cm = np.loadtxt(f"data/calibration/camera_matrix/resulting_data/camera{c}/cmatrix.txt")
        em, mask = cv.findEssentialMat(basePoints, cameraPoints, cm, cv.RANSAC, 0.9999, 1)
        print(f"essential matrix {c} 1:")
        print(em)
        print(f"enforcing internal constrain of essential matrix for camera {c}")
        u, s, v = np.linalg.svd(em)
        em = u.T * np.diag([1, 1, 0]) * v
        print(f"enforced essential matrix {c} :")
        print(em)
        np.savetxt(f"data/calibration/essential_matrix_and_pose/resulting_data/camera{c}/ematrix.txt", em)

以下是我数据的一些标准化样本点:

基础摄像头:

6.899999999999999467e-01 4.066666666666666347e-02
6.899999999999999467e-01 4.066666666666666347e-02
6.913333333333333552e-01 4.066666666666666347e-02
6.919999999999999485e-01 4.066666666666666347e-02
6.946666666666666545e-01 4.066666666666666347e-02
6.986666666666666581e-01 4.133333333333333304e-02
7.026666666666666616e-01 4.133333333333333304e-02
7.073333333333332584e-01 4.199999999999999567e-02
7.119999999999999662e-01 4.266666666666666524e-02
7.173333333333332673e-01 4.466666666666666702e-02

第一台相机:

3.893333333333333091e-01 6.600000000000000311e-02
3.900000000000000133e-01 6.600000000000000311e-02
3.906666666666666621e-01 6.533333333333332660e-02
3.913333333333333108e-01 6.466666666666666397e-02
3.939999999999999614e-01 6.333333333333332482e-02
3.979999999999999649e-01 6.066666666666666735e-02
4.019999999999999685e-01 5.799999999999999600e-02
4.066666666666666763e-01 5.600000000000000117e-02
4.119999999999999774e-01 5.333333333333332982e-02
4.186666666666666314e-01 5.133333333333333498e-02

相机矩阵:

8.830992819912107734e+02 0.000000000000000000e+00 8.279597017259351333e+02
0.000000000000000000e+00 8.678798953432041117e+02 5.529431146654350187e+02
0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00

【问题讨论】:

  • 需要最小的可重复样本。来自 OpenCV 图像校准 cpp 文件。我发现根据棋盘对应集找到正确的姿势没有问题。您的输入数据很可能存在问题。
  • 我使用了在 Blender 中渲染的模拟图像,所以我的点很容易与背景区分开来。我将点绘制到图像上,它们看起来很好。我不确定如何给你一个可重现的样本,因为整个程序有点长,无法添加到帖子中。也许我可以将项目上传到 github 或其他什么?
  • 显示模拟图像对和选定坐标。或者如果你真的有问题。您可以尝试使用给定的样本数据进行 opencv 校准样本,这将向您展示它的工作原理。
  • 前两个图像是基座和第一个凸轮的校准图像。我有100个这样的。在第三张图像中,我绘制了基础相机的所有提取点。这些绘制的点与我的模拟点一致。
  • 选择的坐标?

标签: python opencv camera-calibration 3d-reconstruction


【解决方案1】:

我正在使用您的数据运行。但是我遇到了一个问题,其中一个点在绘图中丢失了,然后我仔细查看了您的数据。

基本相机:点 1 和点 2 相同,这可能会导致矩阵秩不足。任何共线模式都可能导致秩不足。因此,选择足够远的点以确保良好的外极约束合规性

6.899999999999999467e-01 4.066666666666666347e-02

6.899999999999999467e-01 4.066666666666666347e-02

所以我用了你所有的 10 分。结果证明有一个有效的计算输出。表示没有 [0,0,-1]

E [0.3020626878915512, -0.5152322345602659, -0.2301187342264469; 0.4556056566568232,0.3185648205272573,0.2998902206892574; 0.4240482789694776,-0.09650735405531717,0.04705772208405343] 旋转 [0.8636412841012429, 0.5040818976266604, 0.005017258321223739; -0.4976326944200423,0.854097413780324,-0.1512590797870002; -0.0805321913287191,0.1281368341222253,0.9884814201091126] 罗德里格斯 [0.146966997598983, 0.04500046398453182, -0.5269188943544275] 翻译[-0.4250629252517419, -0.4494569974529025, 0.7856907260602315]

这是我的代码。

#include<opencv2/opencv.hpp>

using namespace std;

using namespace cv;
#define M_PI acos(-1.0)
int main(int argc, char *argv[])
{
    std::vector<cv::Point2d> Frame_A_points;
    std::vector<cv::Point2d> Frame_B_points;

    double focalx = 883.;
    double focaly = 867.;

    double focal = (focalx+focaly)/2;
       
    cv::Point2d camera_principal_point(827, 552);    
    Frame_A_points.push_back(Point2d(6.899999999999999467e-01*focalx, 4.066666666666666347e-02*focaly));
    Frame_A_points.push_back(Point2d(6.899999999999999467e-01*focalx, 4.066666666666666347e-02*focaly));
    Frame_A_points.push_back(Point2d(6.913333333333333552e-01*focalx, 4.066666666666666347e-02*focaly));    
    Frame_A_points.push_back(Point2d(6.919999999999999485e-01*focalx, 4.066666666666666347e-02*focaly));
    Frame_A_points.push_back(Point2d(6.946666666666666545e-01*focalx, 4.066666666666666347e-02*focaly)); 
    Frame_A_points.push_back(Point2d(6.986666666666666581e-01*focalx, 4.133333333333333304e-02*focaly));
    Frame_A_points.push_back(Point2d(7.026666666666666616e-01*focalx, 4.133333333333333304e-02*focaly)); 
    Frame_A_points.push_back(Point2d(7.073333333333332584e-01*focalx, 4.199999999999999567e-02*focaly));
    Frame_A_points.push_back(Point2d(7.119999999999999662e-01*focalx, 4.266666666666666524e-02*focaly)); 
    Frame_A_points.push_back(Point2d(7.173333333333332673e-01*focalx, 4.466666666666666702e-02*focaly));

    Frame_B_points.push_back(Point2d(3.893333333333333091e-01*focalx, 6.600000000000000311e-02*focaly));
    Frame_B_points.push_back(Point2d(3.900000000000000133e-01*focalx, 6.600000000000000311e-02*focaly));    
    Frame_B_points.push_back(Point2d(3.906666666666666621e-01*focalx, 6.533333333333332660e-02*focaly));
    Frame_B_points.push_back(Point2d(3.913333333333333108e-01*focalx, 6.466666666666666397e-02*focaly)); 
    Frame_B_points.push_back(Point2d(3.939999999999999614e-01*focalx, 6.333333333333332482e-02*focaly));
    Frame_B_points.push_back(Point2d(3.979999999999999649e-01*focalx, 6.066666666666666735e-02*focaly)); 
    Frame_B_points.push_back(Point2d(4.019999999999999685e-01*focalx, 5.799999999999999600e-02*focaly));
    Frame_B_points.push_back(Point2d(4.066666666666666763e-01*focalx, 5.600000000000000117e-02*focaly)); 
    Frame_B_points.push_back(Point2d(4.119999999999999774e-01*focalx, 5.333333333333332982e-02*focaly));
    Frame_B_points.push_back(Point2d(4.186666666666666314e-01*focalx, 5.133333333333333498e-02*focaly));



    std::cout<< Frame_A_points<< std::endl;


    Mat x(1000, 1000, CV_8UC3, Scalar(0, 0, 0));
    Mat y(1000, 1000, CV_8UC3, Scalar(0, 0, 0));
    double d = 0;
    for (int i = 0; i < Frame_A_points.size(); i++)
    {
        circle(x, Frame_A_points[i], 1, Scalar(0, 0, 255));
        circle(y, Frame_B_points[i], 1, Scalar(0, 255, 255));
        d += norm(Frame_A_points[i] - Frame_B_points[i]);
    }
    cout << "Mean marker distance" << d / Frame_A_points.size() << "\n";
   

 
        cv::Mat essential_matrix = cv::findEssentialMat(Frame_A_points, Frame_B_points, focal, camera_principal_point, cv::LMEDS);
        cv::Mat rotation=Mat::zeros(3,3,CV_64F), translation=Mat::zeros(3, 1, CV_64F);
        cv::recoverPose(essential_matrix, Frame_A_points, Frame_B_points, rotation, translation, focal, camera_principal_point);
        cv::Mat rot(3, 1, CV_64F);
        cv::Rodrigues(rotation, rot);
        //cout << "Essai " << i << " with " << Frame_A_points.size() << "points\n"; 
        std::cout << "E " << essential_matrix << std::endl;
        std::cout << "rotation " << rotation << std::endl;
        std::cout << "rodrigues " << rot.t() << std::endl;
        std::cout << "translation " << translation.t() << std::endl;
     imshow("ptx", x);
    imshow("pty", y);
    waitKey();
}

注意到

平移向量仅按比例缩放。意味着您无法在没有深度 Z 的情况下恢复完整姿势。

您可以参考其他人如何通过将估计的 T 乘以地面实况比例来获得按比例缩放的平移向量

https://github.com/alishobeiri/Monocular-Video-Odometery/blob/master/monovideoodometery.py

    if self.id < 2:
        E, _ = cv2.findEssentialMat(self.good_new, self.good_old, self.focal, self.pp, cv2.RANSAC, 0.999, 1.0, None)
        _, self.R, self.t, _ = cv2.recoverPose(E, self.good_old, self.good_new, self.R, self.t, self.focal, self.pp, None)
    else:
        E, _ = cv2.findEssentialMat(self.good_new, self.good_old, self.focal, self.pp, cv2.RANSAC, 0.999, 1.0, None)
        _, R, t, _ = cv2.recoverPose(E, self.good_old, self.good_new, self.R.copy(), self.t.copy(), self.focal, self.pp, None)

        absolute_scale = self.get_absolute_scale()
        if (absolute_scale > 0.1 and abs(t[2][0]) > abs(t[0][0]) and abs(t[2][0]) > abs(t[1][0])):
            self.t = self.t + absolute_scale*self.R.dot(t)
            self.R = R.dot(self.R)

【讨论】:

    猜你喜欢
    • 1970-01-01
    • 2012-05-10
    • 2013-12-26
    • 2016-02-25
    • 2020-01-15
    • 2019-11-06
    • 2015-01-01
    • 1970-01-01
    • 2016-03-21
    相关资源
    最近更新 更多