视觉SLAM十四讲作业练习（7）直接法BA

最新推荐文章于 2022-09-04 02:16:38 发布
最新推荐文章于 2022-09-04 02:16:38 发布
阅读量287 收藏 1
点赞数
分类专栏： 视觉SLAM 文章标签： c++ 自动驾驶 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ASUNAchan/article/details/125113731
版权

直接法的 Bundle Adjustment

（1）计算误差

​ 通常是在边那个类里面

virtual void computeError() override {
        // TODO START YOUR CODE HERE
        // compute projection error ...
        g2o::VertexSBAPointXYZ *point = static_cast<g2o::VertexSBAPointXYZ*>(_vertices[0]);
        VertexSophus *pose = static_cast<VertexSophus*> (_vertices[1]);
        Eigen::Vector3d pc = pose->estimate() * point->estimate();      //p_c = T * p_w
        double u = (fx * pc[0] + cx * pc[2]) / pc[2];
        double v = (fy * pc[1] + cy * pc[2]) / pc[2];
        if (u - 2 < 0 || v - 2 < 0 || u + 1 >= targetImg.cols || v+1 >= targetImg.cols) {
            // do not optimize 
            this->setLevel(1);
            for (int i = 0; i < 16; ++i) {
                _error[i] = 0;
            }
        }
        // in image
        else {
            // compute photometric error
            for (int i = -2; i < 2; ++i) {
                for (int j = -2; j < 2; ++j) {
                    int num = 4 * i + j + 10;
                    _error[num] = origColor[num] - GetPixelValue(targetImg, u+i, v+j);
                }
            }
        }
}

（2）实例化顶点与边

for (size_t i = 0; i < poses.size(); i++)
    {
        VertexSophus *v = new VertexSophus();
        v->setId(points.size() + i);
        v->setEstimate(poses[i]);
        optimizer.addVertex(v);
    }

    for (size_t i = 0; i < points.size(); i++)
    {
        g2o::VertexSBAPointXYZ *v = new g2o::VertexSBAPointXYZ();
        v->setId(i);
        v->setEstimate(points[i]);
        v->setMarginalized(true);
        optimizer.addVertex(v);
    }

    for (size_t i = 0; i < poses.size(); i++)
    {
        for (size_t j = 0; j < points.size(); j++)
        {
            EdgeDirectProjection *edge = new EdgeDirectProjection(color[j], images[i]);
            edge->setId(i*points.size() + j);
            edge->setVertex(0, dynamic_cast<g2o::VertexSBAPointXYZ*>(optimizer.vertex(j)));
            edge->setVertex(1, dynamic_cast<VertexSophus*>(optimizer.vertex(points.size() + i)));
            edge->setInformation(Eigen::Matrix<double,16,16>::Identity());
            //edge->setRobustKernel(new g2o::RobustKernelHuber());
            g2o::RobustKernelHuber *rk = new g2o::RobustKernelHuber();
            rk->setDelta(1.0); // chi-sqaure threshold for alpha = 0.05 dof = 16
            edge->setRobustKernel(rk);
            optimizer.addEdge(edge);
        }
    }

（3）存储优化后的值

	for (size_t i = 0; i < points.size(); ++i) {
        g2o::VertexSBAPointXYZ *v = static_cast<g2o::VertexSBAPointXYZ*>(optimizer.vertex(i));
        points[i] = v->estimate();
    }

    for (size_t i = 0; i < poses.size(); ++i) {
        VertexSophus *v = static_cast<VertexSophus*>(optimizer.vertex(points.size() + i));
        poses[i] = v->estimate();
    }

（4）CMakeLists.txt

注意点：find_package(Eigen3 REQUIRED NO_MODULE) ，需要添加NO_MODULE，否则cmake时会报错

CMake Error at CMakeLists.txt:25 (find_package):
  Found package configuration file:

    /usr/local/lib/cmake/Pangolin/PangolinConfig.cmake

  but it set Pangolin_FOUND to FALSE so package "Pangolin" is considered to
  be NOT FOUND.  Reason given by package:

  Pangolin could not be found because dependency Eigen3 could not be found.

cmake_minimum_required(VERSION 3.1)
project(directBA)

set(CMAKE_BUILD_TYPE Release)
set(CMAKE_BUILD_FLAGS "-std=c++14 O3")

list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake_modules)

find_package(G2O REQUIRED)
find_package(Eigen3 REQUIRED NO_MODULE)
find_package(Sophus REQUIRED)
find_package(CSparse REQUIRED)
find_package(OpenCV REQUIRED)
find_package(Pangolin REQUIRED)

SET(G2O_LIBS g2o_csparse_extension g2o_stuff g2o_core cxsparse g2o_types_sba)

include_directories(${PROJECT_SOURCE_DIR} 
                    ${EIGEN3_INCLUDE_DIR} 
                    ${CSPARSE_INCLUDE_DIR} 
                    ${OpenCV_INCLUDE_DIRS}
                    ${Pangolin_INCLUDE_DIRS})

add_executable(directBA directBA.cpp)
target_link_libraries(directBA ${G2O_LIBS} ${OpenCV_LIBS} ${Pangolin_LIBRARIES} fmt)
target_link_libraries(directBA Sophus::Sophus )

（5）全部程序

#include <iostream>

using namespace std;

#include <g2o/core/base_unary_edge.h>
#include <g2o/core/base_binary_edge.h>
#include <g2o/core/base_vertex.h>
#include <g2o/core/block_solver.h>
#include <g2o/core/optimization_algorithm_levenberg.h>
#include <g2o/solvers/dense/linear_solver_dense.h>
#include <g2o/core/robust_kernel.h>
#include <g2o/core/robust_kernel_impl.h>
#include <g2o/types/sba/types_six_dof_expmap.h>

#include <Eigen/Core>
#include <sophus/se3.hpp>
#include <opencv2/opencv.hpp>

#include <pangolin/pangolin.h>
#include <boost/format.hpp>

typedef vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>> VecSE3;
typedef vector<Eigen::Vector3d, Eigen::aligned_allocator<Eigen::Vector3d>> VecVec3d;

// global variables
string pose_file = "../poses.txt";
string points_file = "../points.txt";

// intrinsics
float fx = 277.34;
float fy = 291.402;
float cx = 312.234;
float cy = 239.777;

// bilinear interpolation
inline float GetPixelValue(const cv::Mat &img, float x, float y) {
    uchar *data = &img.data[int(y) * img.step + int(x)];
    float xx = x - floor(x);
    float yy = y - floor(y);
    return float(
            (1 - xx) * (1 - yy) * data[0] +
            xx * (1 - yy) * data[1] +
            (1 - xx) * yy * data[img.step] +
            xx * yy * data[img.step + 1]
    );
}

// g2o vertex that use sophus::SE3 as pose
class VertexSophus : public g2o::BaseVertex<6, Sophus::SE3d> {
public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW

    VertexSophus() {}

    ~VertexSophus() {}

    bool read(std::istream &is) {return false;}

    bool write(std::ostream &os) const {return false;}

    virtual void setToOriginImpl() {
        _estimate = Sophus::SE3d();
    }

    virtual void oplusImpl(const double *update_) {
        Eigen::Map<const Eigen::Matrix<double, 6, 1>> update(update_);
        setEstimate(Sophus::SE3d::exp(update) * estimate());
    }
};

// TODO edge of projection error, implement it
// 16x1 error, which is the errors in patch
typedef Eigen::Matrix<double,16,1> Vector16d;
class EdgeDirectProjection : public g2o::BaseBinaryEdge<16, Vector16d, g2o::VertexSBAPointXYZ, VertexSophus> {
public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW;

    EdgeDirectProjection(float *color, cv::Mat &target) {
        this->origColor = color;
        this->targetImg = target;
    }

    ~EdgeDirectProjection() {}

    virtual void computeError() override {
        // TODO START YOUR CODE HERE
        // compute projection error ...
        g2o::VertexSBAPointXYZ *point = static_cast<g2o::VertexSBAPointXYZ*>(_vertices[0]);
        VertexSophus *pose = static_cast<VertexSophus*> (_vertices[1]);
        Eigen::Vector3d pc = pose->estimate() * point->estimate();      //p_c = T * p_w
        double u = (fx * pc[0] + cx * pc[2]) / pc[2];
        double v = (fy * pc[1] + cy * pc[2]) / pc[2];
        if (u - 2 < 0 || v - 2 < 0 || u + 1 >= targetImg.cols || v+1 >= targetImg.cols) {
            // do not optimize 
            this->setLevel(1);
            for (int i = 0; i < 16; ++i) {
                _error[i] = 0;
            }
        }
        // in image
        else {
            // compute photometric error
            for (int i = -2; i < 2; ++i) {
                for (int j = -2; j < 2; ++j) {
                    int num = 4 * i + j + 10;
                    _error[num] = origColor[num] - GetPixelValue(targetImg, u+i, v+j);
                }
            }
        }

        // END YOUR CODE HERE
    }

    // Let g2o compute jacobian for you
    /*
    virtual void linearizeOplus() override {
        if (level() == 1) {
            _jacobianOplusXi = Eigen::Matrix<double, 16, 3>::Zero();
            _jacobianOplusXj = Eigen::Matrix<double, 16, 6>::Zero();
            return;
        }

        const g2o::VertexSBAPointXYZ *point = static_cast<const g2o::VertexSBAPointXYZ * >(_vertices[0]);
        const VertexSophus *pose = static_cast<const VertexSophus * >(_vertices[1]);
        Eigen::Vector3d Pc = pose->estimate() * point->estimate();

        float x = Pc[0];
        float y = Pc[1];
        float z = Pc[2];
        
        float inv_z = 1.0 / z;
        float inv_z2 = inv_z * inv_z;
        float u = x * inv_z * fx + cx;
        float v = y * inv_z * fy + cy;

        // J_u_q = [fx/Z 0    -fx*X/Z^2]
        //         [0    fy/Z -fy*Y/Z^2]
        Eigen::Matrix<double, 2, 3> J_u_q;
        J_u_q(0, 0) = fx * inv_z;
        J_u_q(0, 1) = 0;
        J_u_q(0, 2) = -fx * x * inv_z2;
        J_u_q(1, 0) = 0;
        J_u_q(1, 1) = fy * inv_z;
        J_u_q(1, 2) = -fy * y * inv_z2;

        // J_q_esp = [I, -q^]
        Eigen::Matrix<double, 3, 6> J_q_esp = Eigen::Matrix<double, 3, 6>::Zero();
        J_q_esp(0, 0) = 1;
        J_q_esp(0, 4) = z;
        J_q_esp(0, 5) = -y;
        J_q_esp(1, 1) = 1;
        J_q_esp(1, 3) = -z;
        J_q_esp(1, 5) = x;
        J_q_esp(2, 2) = 1;
        J_q_esp(2, 3) = y;
        J_q_esp(2, 4) = -x;

        Eigen::Matrix<double, 1, 2> J_I_uv;
        for (int i = -2; i < 2; i++)
            for (int j = -2; j < 2; j++) {
                int num = 4 * i + j + 10;
                // 
                J_I_uv(0, 0) =
                        (GetPixelValue(targetImg, u + i + 1, v + j) - GetPixelValue(targetImg, u + i - 1, v + j)) / 2;
                J_I_uv(0, 1) =
                        (GetPixelValue(targetImg, u + i, v + j + 1) - GetPixelValue(targetImg, u + i, v + j - 1)) / 2;
                _jacobianOplusXi.block<1, 3>(num, 0) = -J_I_uv * J_u_q * pose->estimate().rotationMatrix();
                _jacobianOplusXj.block<1, 6>(num, 0) = -J_I_uv * J_u_q * J_q_esp;
            }
    }
    */
    virtual bool read(istream &in) {return false;}

    virtual bool write(ostream &out) const {return false;}

private:
    cv::Mat targetImg;  // the target image
    float *origColor = nullptr;   // 16 floats, the color of this point
};

// plot the poses and points for you, need pangolin
void Draw(const VecSE3 &poses, const VecVec3d &points);

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

    // read poses and points
    VecSE3 poses;
    VecVec3d points;
    ifstream fin(pose_file);

    while (!fin.eof()) {
        double timestamp = 0;
        fin >> timestamp;
        if (timestamp == 0) break;
        double data[7];
        for (auto &d: data) fin >> d;
        poses.push_back(Sophus::SE3d(
                Eigen::Quaterniond(data[6], data[3], data[4], data[5]),
                Eigen::Vector3d(data[0], data[1], data[2])
        ));
        if (!fin.good()) break;
    }
    fin.close();


    vector<float *> color;
    fin.open(points_file);
    while (!fin.eof()) {
        double xyz[3] = {0};
        for (int i = 0; i < 3; i++) fin >> xyz[i];
        if (xyz[0] == 0) break;
        points.push_back(Eigen::Vector3d(xyz[0], xyz[1], xyz[2]));
        float *c = new float[16];
        for (int i = 0; i < 16; i++) fin >> c[i];
        color.push_back(c);

        if (!fin.good()) break;
    }
    fin.close();

    cout << "poses: " << poses.size() << ", points: " << points.size() << endl;

    // read images
    vector<cv::Mat> images;
    boost::format fmt("../%d.png");
    for (int i = 0; i < 7; i++) {
        images.push_back(cv::imread((fmt % i).str(), 0));
    }

    // build optimization problem
    typedef g2o::BlockSolver<g2o::BlockSolverTraits<6, 3>> DirectBlock; 
    std::unique_ptr<DirectBlock::LinearSolverType> linearSolver (new g2o::LinearSolverDense<DirectBlock::PoseMatrixType>());
    std::unique_ptr<DirectBlock> solver_ptr (new DirectBlock(move(linearSolver)));
    g2o::OptimizationAlgorithmLevenberg *solver = new g2o::OptimizationAlgorithmLevenberg(move(solver_ptr)); // L-M
    
    g2o::SparseOptimizer optimizer;
    optimizer.setAlgorithm(solver);
    optimizer.setVerbose(true);

    // TODO add vertices, edges into the graph optimizer
    // START YOUR CODE HERE

    for (size_t i = 0; i < poses.size(); i++)
    {
        VertexSophus *v = new VertexSophus();
        v->setId(points.size() + i);
        v->setEstimate(poses[i]);
        optimizer.addVertex(v);
    }

    for (size_t i = 0; i < points.size(); i++)
    {
        g2o::VertexSBAPointXYZ *v = new g2o::VertexSBAPointXYZ();
        v->setId(i);
        v->setEstimate(points[i]);
        v->setMarginalized(true);
        optimizer.addVertex(v);
    }

    for (size_t i = 0; i < poses.size(); i++)
    {
        for (size_t j = 0; j < points.size(); j++)
        {
            EdgeDirectProjection *edge = new EdgeDirectProjection(color[j], images[i]);
            edge->setId(i*points.size() + j);
            edge->setVertex(0, dynamic_cast<g2o::VertexSBAPointXYZ*>(optimizer.vertex(j)));
            edge->setVertex(1, dynamic_cast<VertexSophus*>(optimizer.vertex(points.size() + i)));
            edge->setInformation(Eigen::Matrix<double,16,16>::Identity());
            //edge->setRobustKernel(new g2o::RobustKernelHuber());
            g2o::RobustKernelHuber *rk = new g2o::RobustKernelHuber();
            rk->setDelta(1.0); // chi-sqaure threshold for alpha = 0.05 dof = 16
            edge->setRobustKernel(rk);
            optimizer.addEdge(edge);
        }
    }
    

    // END YOUR CODE HERE

    // perform optimization
    optimizer.initializeOptimization(0);
    optimizer.optimize(200);

    // TODO fetch data from the optimizer
    // START YOUR CODE HERE
    for (size_t i = 0; i < points.size(); ++i) {
        g2o::VertexSBAPointXYZ *v = static_cast<g2o::VertexSBAPointXYZ*>(optimizer.vertex(i));
        points[i] = v->estimate();
    }

    for (size_t i = 0; i < poses.size(); ++i) {
        VertexSophus *v = static_cast<VertexSophus*>(optimizer.vertex(points.size() + i));
        poses[i] = v->estimate();
    }
    // END YOUR CODE HERE

    // plot the optimized points and poses
    Draw(poses, points);

    // delete color data
    for (auto &c: color) delete[] c;
    return 0;
}

void Draw(const VecSE3 &poses, const VecVec3d &points) {
    if (poses.empty() || points.empty()) {
        cerr << "parameter is empty!" << endl;
        return;
    }

    // create pangolin window and plot the trajectory
    pangolin::CreateWindowAndBind("Trajectory Viewer", 1024, 768);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    pangolin::OpenGlRenderState s_cam(
            pangolin::ProjectionMatrix(1024, 768, 500, 500, 512, 389, 0.1, 1000),
            pangolin::ModelViewLookAt(0, -0.1, -1.8, 0, 0, 0, 0.0, -1.0, 0.0)
    );

    pangolin::View &d_cam = pangolin::CreateDisplay()
            .SetBounds(0.0, 1.0, pangolin::Attach::Pix(175), 1.0, -1024.0f / 768.0f)
            .SetHandler(new pangolin::Handler3D(s_cam));


    while (pangolin::ShouldQuit() == false) {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        d_cam.Activate(s_cam);
        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

        // draw poses
        float sz = 0.1;
        int width = 640, height = 480;
        for (auto &Tcw: poses) {
            glPushMatrix();
            Sophus::Matrix4f m = Tcw.inverse().matrix().cast<float>();
            glMultMatrixf((GLfloat *) m.data());
            glColor3f(1, 0, 0);
            glLineWidth(2);
            glBegin(GL_LINES);
            glVertex3f(0, 0, 0);
            glVertex3f(sz * (0 - cx) / fx, sz * (0 - cy) / fy, sz);
            glVertex3f(0, 0, 0);
            glVertex3f(sz * (0 - cx) / fx, sz * (height - 1 - cy) / fy, sz);
            glVertex3f(0, 0, 0);
            glVertex3f(sz * (width - 1 - cx) / fx, sz * (height - 1 - cy) / fy, sz);
            glVertex3f(0, 0, 0);
            glVertex3f(sz * (width - 1 - cx) / fx, sz * (0 - cy) / fy, sz);
            glVertex3f(sz * (width - 1 - cx) / fx, sz * (0 - cy) / fy, sz);
            glVertex3f(sz * (width - 1 - cx) / fx, sz * (height - 1 - cy) / fy, sz);
            glVertex3f(sz * (width - 1 - cx) / fx, sz * (height - 1 - cy) / fy, sz);
            glVertex3f(sz * (0 - cx) / fx, sz * (height - 1 - cy) / fy, sz);
            glVertex3f(sz * (0 - cx) / fx, sz * (height - 1 - cy) / fy, sz);
            glVertex3f(sz * (0 - cx) / fx, sz * (0 - cy) / fy, sz);
            glVertex3f(sz * (0 - cx) / fx, sz * (0 - cy) / fy, sz);
            glVertex3f(sz * (width - 1 - cx) / fx, sz * (0 - cy) / fy, sz);
            glEnd();
            glPopMatrix();
        }

        // points
        glPointSize(2);
        glBegin(GL_POINTS);
        for (size_t i = 0; i < points.size(); i++) {
            glColor3f(0.0, points[i][2]/4, 1.0-points[i][2]/4);
            glVertex3d(points[i][0], points[i][1], points[i][2]);
        }
        glEnd();

        pangolin::FinishFrame();
        usleep(5000);   // sleep 5 ms
    }
}
花舞の街道
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Bundle Adjustment简述
记起来就随便写写
03-21 5万+
关于Bundle Adjustment简要介绍
SLAM代码（光束平差法BA)
何必浓墨重彩
09-03 2591
定义给出从不同视角拍摄的，描述同一个场景的一系列图片，bundle adjustment可以根据所有点在图像中的投影作为标准，同时提炼出描述场景结构的3D点坐标、相对运动参数和相机的光学参数。 [mutliple view geometry]如果数据中包含噪声,透视投影模型并不满足xij=PXjx^i_j = \mathbf{P}X_j,这种情况下寻找一个最大似然解,这样假设测量的数据符合高斯分布
Windows编译安装Eigen
Qrpucp的博客
09-28 4526
1.版本说明 平台：Windows 10 编译器：mingw，gcc/g++ 8.1.0 CMake版本：3.21.3 Eigen版本：3.4.0 2.编译安装 首先到 Eigen 的官网上面下载最新的源码，3.4.0版本的源码在这里。 打开 cmake-gui ，where is the source code 处选择刚刚下载并解压的源码文件夹， 在之中新建一个 build 文件夹，在 where to build the binaries 处选择该文件夹。 由于 cmake-gui 生成的默认安装路径有
Eigen多版本库安装以及cmake包含使用
qq_43526137的博客
07-12 2482
eigen安装以及find_package使用
Eigen的初步了解
mantou_riji的博客
03-11 655
1.Eigen是什么？ eigen是c++的一个关于线性代数的第三方库,使用该库函数可以实现线性代数运算，矩阵和矢量运算，数值分析及其相关的算法。 2.Eigen在ubuntu进行安装 sudo apt-get install libeigen3-dev 3.配置环境 在学习ROS时，遇到库函数Eigen，作用是计算三维空间的位置距离，在编译的时候会在包下产生CMakeList.txt文件，我们需要将相应的依赖包填写在CMakeList.txt终： （1）find_package(……Eigen3 REQ
深蓝学院-视觉SLAM十四讲-第七章作业
记录和分享
11-16 2378
第七节课作业 2. Bundle Adjustment 2.1 文献阅读 为何说Bundle Adjustment is slow 是不对的？ 在之前的文献中，BA一直被误认为是比较慢的，因为没有考虑到问题的结构和稀疏性。直接对HHH求逆来计算增量方程，会消耗很多计算资源，也就显得比较慢。实际上，由于HHH具有稀疏结构，是可以使用加速技巧进行求解的。而经过处理的BA，通常比其他新的方法更快，更有效。 BA 中有哪些需要注意参数化的地⽅？Pose 和Point 各有哪些参数化⽅式？有何优缺点。 3D
Bundle adjustment 总结
pikachu_777的专栏
04-04 960
BA 最小化重投影误差： X=argmin∑i=1Ni∑j=1Nj∣∣ei,j(X)∣∣X=argmin\sum_{i=1}^{N_i}\sum_{j=1}^{N_j}||e_{i,j}(X)||X=argmini=1∑Ni​​j=1∑Nj​​∣∣ei,j​(X)∣∣ 求解方法： 使用LM算法优化求最优解。每一次迭代中的增量求解为： δX∗=argmin∣∣J(X)δX+E(X)∣∣+λ∣∣D(X...
视觉SLAM十四讲 第八讲 视觉里程计2 8.5直接法BA法 代码解析
Bettyshasha的专栏
03-24 742
总体思路 提取特征点 构建图优化问题 边（误差项），在直接法中为光度误差 边的增量项 光度误差相对于李代数的雅可比矩阵： 图像坐标对李代数的雅可比矩阵 为 u 处的像素梯度 边的误差项 _error ( 0,0 ) = getPixelValue ( x,y ) - _measurement; g2o优化库 增加顶点 增加边（每个特征点一条边） 优化迭代 代码 #include <iostr...
FindEigen.cmake
12-01
cmake_module 中的FindEigen.cmake文件，可直接找到eigen3文件夹
Ceres Solver 官方教程学习笔记（五）——光束法平差Bundle Adjustment
小政哥的私房博客
03-27 9087
本文主要根据Ceres官方教程翻译的来。 开发Ceres库的一个重要出发点就是计算光束法平差Bundle Adjustment，简称BA。 关于光束法平差的原理可以参考这篇博客《Bundle Adjustment简述》 现简单的概况如下： 空间中一个点在成像平面的坐标系中投影成一个像素。这个投影称为初次投影。如果我们有多个相机，可以根据空间中同一点在不同相机中的投影（即像素坐标）来反...
bundle adjustment算法学习
Where there is life, there is hope
11-27 1万+
今天学习了稀疏的光束平差法，基于上一篇博文Levenberg–Marquardt算法学习，这里对学习内容做一个理论梳理。本次内容包括：BA简介BA迭代步长的数学推导稀疏BA迭代步长的算法求解过程1.BA简介   摄像机在静态环境中移动，得到不同时刻拍摄的多幅图像。假设这些图像是同一刚性物体的投影，则可由图像特征对应关系估计出摄像机的运动参数。在计算机视觉中 ，这一过程称为运动分析或由运动重建物体结
fatal error: sophus/se3.h: 没有那个文件或目录
fb_941219的博客
03-01 1万+
fatal error: sophus/se3.h: 没有那个文件或目录0.引言1.原因2.非模板类sophus3.模板类sophus 0.引言 sophus已经安装，但是编译代码报错：fatal error: sophus/se3.h: 没有那个文件或目录 1.原因 sophus版本问题。老版本sophus是非模板类的Sophus。最新sophus为模板类的Sophus，代码会有点变化。 2.非...
SLAM14讲中Sophus包的安装问题
alex1801
06-21 1240
SLAM14中，useSophus.cpp工程编译中报错： 报错原因：makelist中找不到Sophus头文件。我们分两步处理： 进入源码目录，编译，安装。 2、在CMakeLists.txt文件中添加Sophus_INCLUDE_DIRS变量 观看错误信息，其实就是找不到Sophus库和头文件的内容： 比如，我的是这样的： 然后再将你的执行文件链接上Sophus库文件。这样的话，上述编译错误应该就可以消失了。...
Sophus库安装踩坑（SLAM十四讲）
一只小菜鸟的博客
03-11 2万+
学习slam十四讲（第二版），自行git安装sophus库，但是需要做准备工作 注意，如果看网上的其他教程可能会出错，因为大部分教程是根据第一版的书，使用的是非模板类，但是这里使用的是模板类的sophus 0.准备工作 因为sophus的使用必须依赖eigen库，因此先下载eigen，但是如果你有3.3以下的版本的eigen，那么请先卸载： 0.0 如果你有以前的eigen版本，则先卸载 （1）如...
g2o报错修改
weixin_50862344的博客
09-04 1087
g2o报错修改
SLAM笔记（五）光束平差法(Bundle Adjustment)
热门推荐
一只飞鱼的博客
04-09 2万+
1.什么是光束平差法 前边的八点法，五点法等可以求出闭式解的前提是已经知道确切的点对。但实际情况中往往存在大量的噪声，点与点不是精确地对应甚至出现一些错误匹配。 光束平差法由Bundle Adjustment翻译得来，有两层意思： 对场景中任意三维点P，由从每个视图所对应的的摄像机的光心发射出来并经过图像中P对应的像素后的光线，都将交于P这一点，对于所有三维点，则形成相当多的光束（bundl...
VS2019编译（拷贝）Eigen库
tanmx219的博客
04-10 1972
今天编译meshlab，cmake-gui报错： Could not find a package configuration file provided by "Eigen3" with any of the following names: Eigen3Config.cmake eigen3-config.cmake 于是找了一下Eigen3Config.cmake到底是个什么东西，先说结果，最后其内容如下， # This file exports the Eige
深蓝学院视觉slam十四讲第７章作业
Jevin-L的博客
07-23 2395
目录2. Bundle Adjustment2.1 文献阅读2.2 BAL-dataset3. 直接法的 Bundle Adjustment3.1 数学模型3.2 实现 2. Bundle Adjustment 2.1 文献阅读 1.矩阵Ｈ具有稀疏性，对角块矩阵有加速计算技巧 2.相机内参　位姿　3D点坐标　投影后的像素坐标； pose： 欧拉角/四元数/旋转矩阵/李代数＋平移坐标 point：齐次和齐次 3.文中提到的“网络图”即“图优化”当下几乎代替了以往的滤波算法 2.2 BAL-dataset
视觉slam十四讲ch7
最新发布
08-27
《视觉SLAM十四讲》的第七章主要介绍了ORB特征的手写实现。ORB特征是一种基于FAST角点检测和BRIEF描述子的特征提取方法，它在计算效率和鲁棒性上表现出色，被广泛应用于视觉SLAM中。 第七章还介绍了ORB特征的主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值