视觉SLAM十四讲作业练习（3）

已于 2022-05-03 19:57:54 修改
阅读量648 收藏 2
点赞数
分类专栏： 视觉SLAM 文章标签： c++ 开发语言
于 2022-05-03 19:47:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ASUNAchan/article/details/124560252
版权

.5 sophus的使用

书中提供的代码

useSophus.cpp

#include <iostream>
#include <cmath>
#include <Eigen/Core>
#include <Eigen/Geometry>

#include "sophus/se3.hpp"
#include "sophus/so3.hpp"

using namespace std;
using namespace Eigen;

int main(int argc, char *argv[])
{
    //沿z轴旋转90度的旋转矩阵
    Matrix3d R = AngleAxisd(M_PI / 2, Vector3d(0, 0, 1)).toRotationMatrix();

    //四元数
    Quaterniond q(R);
    Sophus::SO3d SO3_R(R);   //Sophus::SO3d可以直接从旋转矩阵构造
    Sophus::SO3d SO3_q(q);   //也可通过四元数构造

    cout << "SO(3) from matrix: \n" << SO3_R.matrix() << endl;
    cout << "SO(3) from quaternion: \n" << SO3_q.matrix() << endl;
    cout << "上述二者等价！" << endl;

    //使用对数映射获得它的李代数
    Vector3d so3 = SO3_R.log();
    cout << "so3 = " << so3.transpose() << endl;

    //hat为向量到反对称矩阵
    cout << "so3 hat = \n" << Sophus::SO3d::hat(so3) << endl;
    //vee 为反对称到向量
    cout << "so3 hat vee = \n" << Sophus::SO3d::vee(Sophus::SO3d::hat(so3)).transpose() << endl;
    
    //增量扰动模型的更新
    Vector3d updated_so3(1e-4, 0, 0);    //假设的更新量
    Sophus::SO3d SO3_updated = Sophus::SO3d::exp(updated_so3) * SO3_R;
    cout << "SO3 updated = \n" << SO3_updated.matrix() << endl;

    cout << "---------------------------------------------------------------" << endl;
    //对SE(3)操作大同小异
    Vector3d t(1, 0, 0);    //沿x周平移1
    Sophus::SE3d SE3_Rt(R, t);  //由R,t构造SE(3)
    Sophus::SE3d SE3_qt(q, t);

    cout << "SE(3) from matrix: \n" << SE3_Rt.matrix() << endl;
    cout << "SE(3) from quaternion: \n" << SE3_qt.matrix() << endl;

    //李代数为se(3)为一个六维向量
    typedef Eigen::Matrix<double, 6, 1> Vector6d;
    Vector6d se3 = SE3_Rt.log();
    cout << "se3 = " << se3.transpose() << endl;

    cout << "se3 hat = \n" << Sophus::SE3d::hat(se3) << endl;
    cout << "se3 hat vee = \n" << Sophus::SE3d::vee(Sophus::SE3d::hat(se3)).transpose() << endl;


    Vector6d update_se3;    //更新量
    update_se3.setZero();
    update_se3(0, 0) = 1e-4;
    Sophus::SE3d SE3_updated = Sophus::SE3d::exp(update_se3) * SE3_Rt;
    cout << "SE3 updated = \n" << SE3_updated.matrix() << endl;

    return 0;
}

关键：CMakeLists.txt 的编写

按照书中所写的代码，在我的电脑上会报错

1）需要添加eigen3

有点奇怪，重新试了一下发现不需要了。。。。

2）target_link_libraries(useSophus Sophus::Sophus )必需,不然会报超级多的错误。

解决来源：https://blog.csdn.net/weixin_44387324/article/details/118904871

3）target_link_libraries(useSophus ${Sophus_LIBRARIES})感觉最好加上

cmake_minimum_required(VERSION 2.8)
project(useSophus)

find_package(Sophus REQUIRED)
include_directories(${Sophus_INCLUDE_DIR})

include_directories(/usr/local/include/eigen3)
add_executable(useSophus useSophus.cpp)
target_link_libraries(useSophus Sophus::Sophus )
#target_link_libraries(useSophus ${Sophus_LIBRARIES})

7.轨迹的描绘

draw_trajectory.cpp

#include <string>
#include <iostream>
#include <fstream>
#include <unistd.h>

#include <sophus/se3.hpp>

// need pangolin for plotting trajectory
#include <pangolin/pangolin.h>

using namespace std;

// path to trajectory file
string trajectory_file = "../trajectory.txt";

// function for plotting trajectory, don't edit this code
// start point is red and end point is blue
void DrawTrajectory(vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>>);

bool ReadTrajectory(const string &trajectory_file_path, vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>> &poses);

int main(int argc, char **argv) {
    /*
        vector<Sophus::SE3, Eigen::aligned_allocator< Sophus::SE3>> poses;
        //这句实际上表达的是vector< Sophus::SE3> poses的意思
        但是在Eigen管理内存和C++11中的方法是不一样的，所以需要单独强调元素的内存分配和管理。
        (特别注意Eigen库数据结构内存对齐问题)
    */
    vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>> poses; //vector容器

    // 读取文件
    if (!ReadTrajectory(trajectory_file, poses)) {
        cout << "读取失败...\n";
    } 
    else {
        cout << "读取成功!\n";
    }

    // draw trajectory in pangolin
    DrawTrajectory(poses);
    return 0;
}

bool ReadTrajectory(const string &trajectory_file_path, vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>> &poses){
    // 读文件
    // 2创建流对象
    ifstream reader;

    // 3.1打开文件
    reader.open(trajectory_file_path, ios::in);
    
    // 3.2判断是否打开成功
    if (!reader.is_open()) {
        cout << "文件打开失败！！！ " << trajectory_file_path << '\n';
        return false;
    }

    // 4读数据
    // 将读到的数据储存在SE(3)矩阵中
    Eigen::Quaterniond q(1,0,0,0);  //四元数
    Eigen::Vector3d t(0,0,0);       //平移
    double time;

    while (!reader.eof())   //eof() 判断文件是否为空或者是否读到文件结尾
    {   //文件存储的格式为[t,tx,ty,tz,qx,qy,qz]
        reader >> time;
        // read t
        reader >> t[0];
        reader >> t[1];
        reader >> t[2];
        // read q
        reader >> q.x();
        reader >> q.y();
        reader >> q.z();
        reader >> q.w();
        Sophus::SE3d SE3 (q,t);
        poses.push_back(SE3);
    }

    reader.close();

    return true;
}

void DrawTrajectory(vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>> poses) {
    if (poses.empty()) {
        cerr << "Trajectory is empty!\n";
        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(1.0f, 1.0f, 1.0f, 1.0f);

        glLineWidth(2);
        for (size_t i = 0; i < poses.size() - 1; i++) {
            glColor3f(1 - (float) i / poses.size(), 0.0f, (float) i / poses.size());
            glBegin(GL_LINES);
            auto p1 = poses[i], p2 = poses[i + 1];
            glVertex3d(p1.translation()[0], p1.translation()[1], p1.translation()[2]);
            glVertex3d(p2.translation()[0], p2.translation()[1], p2.translation()[2]);
            glEnd();
        }
        pangolin::FinishFrame();
        usleep(5000);   // sleep 5 ms
    }
}

数据读取部分代码

bool ReadTrajectory(const string &trajectory_file_path, vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>> &poses){
    // 读文件
    // 2创建流对象
    ifstream reader;

    // 3.1打开文件
    reader.open(trajectory_file_path, ios::in);
    
    // 3.2判断是否打开成功
    if (!reader.is_open()) {
        cout << "文件打开失败！！！ " << trajectory_file_path << '\n';
        return false;
    }

    // 4读数据
    // 将读到的数据储存在SE(3)矩阵中
    Eigen::Quaterniond q(1,0,0,0);  //四元数
    Eigen::Vector3d t(0,0,0);       //平移
    double time;

    while (!reader.eof())   //eof() 判断文件是否为空或者是否读到文件结尾
    {   //文件存储的格式为[t,tx,ty,tz,qx,qy,qz]
        reader >> time;
        // read t
        reader >> t[0];
        reader >> t[1];
        reader >> t[2];
        // read q
        reader >> q.x();
        reader >> q.y();
        reader >> q.z();
        reader >> q.w();
        Sophus::SE3d SE3 (q,t);
        poses.push_back(SE3);	//在vector尾部加入一个数据
    }

    reader.close();

    return true;
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.1)
project(trajectory)

find_package(Pangolin REQUIRED)
include_directories(${Pangolin_INCLUDE_DIRS})

find_package(Sophus REQUIRED)
include_directories(${Sophus_INCLUDE_DIR})

add_executable(draw_trajectory draw_trajectory.cpp)
target_link_libraries(draw_trajectory Sophus::Sophus )
target_link_libraries(draw_trajectory ${Pangolin_LIBRARIES} ${Sophus_LIBRARIES})

8.轨迹的误差

与上节相比需添加轨迹误差的计算，以及将两个轨迹画到同一个图中

误差计算（课本上有）：

double ComputeRMSE( const vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>>& poses_estimated,
                    const vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>>& poses_groundtruth) {
    //算法参考课本
    double rmse = 0.0;
    for (int i = 0; i < poses_estimated.size(); i++) {
        Sophus::SE3d p_true = poses_groundtruth[i];
        Sophus::SE3d p_esti = poses_estimated[i];
        // Compute norm of error
        double error = (p_true.inverse() * p_esti).log().norm();
        rmse += error * error;
    }

    rmse = sqrt(rmse / double(poses_estimated.size()));

    return rmse;
}

主程序：

#include <string>
#include <iostream>
#include <fstream>
#include <vector>
#include <pangolin/pangolin.h>
#include <unistd.h>
#include <sophus/se3.hpp>

using namespace std;

string estimation_file_path = "../estimated.txt";
string groundtruth_file_path = "../groundtruth.txt";

bool ReadTrajectory(const string &trajectory_file_path, std::vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>> &poses){
    // 读文件
    // 2创建流对象
    ifstream reader;

    // 3.1打开文件
    reader.open(trajectory_file_path, ios::in);
    
    // 3.2判断是否打开成功
    if (!reader.is_open()) {
        cout << "文件打开失败！！！ " << trajectory_file_path << '\n';
        return false;
    }

    // 4读数据
    // 将读到的数据储存在SE(3)矩阵中
    Eigen::Quaterniond q(1,0,0,0);  //四元数
    Eigen::Vector3d t(0,0,0);       //平移
    double time;

    while (!reader.eof())   //eof() 判断文件是否为空或者是否读到文件结尾
    {   //文件存储的格式为[t,tx,ty,tz,qx,qy,qz]
        reader >> time;
        // read t
        reader >> t[0];
        reader >> t[1];
        reader >> t[2];
        // read q
        reader >> q.x();
        reader >> q.y();
        reader >> q.z();
        reader >> q.w();
        Sophus::SE3d SE3 (q,t);
        poses.push_back(SE3);
    }

    reader.close();

    return true;
}

double ComputeRMSE( const vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>>& poses_estimated,
                    const vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>>& poses_groundtruth) {
    //算法参考课本
    double rmse = 0.0;
    for (int i = 0; i < poses_estimated.size(); i++) {
        Sophus::SE3d p_true = poses_groundtruth[i];
        Sophus::SE3d p_esti = poses_estimated[i];
        // Compute norm of error
        double error = (p_true.inverse() * p_esti).log().norm();
        rmse += error * error;
    }

    rmse = sqrt(rmse / double(poses_estimated.size()));

    return rmse;
}

void DrawTrajectory(vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>> &poses_estimated,
                    vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>> &poses_groundtruth) 
{
    if (poses_estimated.empty()) {
        cerr << "Trajectory_esti is empty!\n";
        return;
    }
    if (poses_groundtruth.empty()) {
        cerr << "Trajectory_true is empty!\n";
        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(1.0f, 1.0f, 1.0f, 1.0f);

        glLineWidth(2);
        for (size_t i = 0; i < poses_estimated.size() - 1; i++) {
            glColor3f(1 - (float) i / poses_estimated.size(), 0.0f, (float) i / poses_estimated.size());
            glBegin(GL_LINES);
            auto p1 = poses_estimated[i], p2 = poses_estimated[i + 1];
            glVertex3d(p1.translation()[0], p1.translation()[1], p1.translation()[2]);
            glVertex3d(p2.translation()[0], p2.translation()[1], p2.translation()[2]);
            glEnd();
        }        
        for (size_t i = 0; i < poses_groundtruth.size() - 1; i++) {
            glColor3f(1 - (float) i / poses_groundtruth.size(), 0.0f, (float) i / poses_groundtruth.size());
            glBegin(GL_LINES);
            auto p1_t = poses_groundtruth[i], p2_t = poses_groundtruth[i + 1];
            glVertex3d(p1_t.translation()[0], p1_t.translation()[1], p1_t.translation()[2]);
            glVertex3d(p2_t.translation()[0], p2_t.translation()[1], p2_t.translation()[2]);
            glEnd();
        }
        pangolin::FinishFrame();
        usleep(5000);   // sleep 5 ms
    }
}

int main(int argc, char** argv) {
    vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>> poses_estimated;
    vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>> poses_groundtruth;

    // read estimation file
    if (!ReadTrajectory(estimation_file_path, poses_estimated)) {
        cout << "Reading estimation file fails...\n";
    } 
    else {
        cout << "Reading estimation file succeeds!\n";
    }

    // read groundtruth file
    if (!ReadTrajectory(groundtruth_file_path, poses_groundtruth)) {
        cout << "Reading groundtruth file fails...\n";
    } 
    else {
        cout << "Reading groundtruth file succeeds!\n";
    }

    cout << ComputeRMSE(poses_estimated, poses_groundtruth) << '\n';

    DrawTrajectory(poses_estimated,poses_groundtruth);

    return 0;
}

总结与反思：此程序总共分为三部分，一是将文件中的数据读入，二是通过pangolin库将读入的轨迹数据画出来，三是误差算法。欠缺的地方是使用pangoin库画出轨迹，因为看视频的时候没认真看，作业也仅仅是现在才开始练习，接下来学习一下这个可视化绘图库吧。

花舞の街道
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
视觉SLAM十四讲（第三章作业）
weixin_37661692的博客
10-12 2176
群的性质 1. {Z; +} 是否为群？若是，验证其满足群定义；若不是，说明理由。 答： 2. {N; +} 是否为群？若是，验证其满足群定义；若不是，说明理由。 答：同理如上，也是阿贝尔群。 验证向量叉乘的李代数性质 推导 SE(3) 的指数映射 伴随 轨迹的描述 熟悉C++11 ...
视觉SLAM十四讲（3）
weixin_44053287的博客
03-27 881
视觉SLAM十四讲（3）——相机与图像
高翔视觉slam十四讲有完整库的代码文件
09-20
高翔视觉slam十四讲有完整库的代码文件 ： 因为高翔视觉slam十四讲文件里面的，3rdparty文件夹下下载下来是空的，所以这里有专门的已经下载好了的文件夹供大家使用，不用再自己下载了，避免因版本不同而编译错误。 操作： 1、库文件中如果有build文件夹的，先删除build文件夹。 2、然后 cmake .. 3、make -j4, 编译成功，运行各章节的代码文件。
视觉slam十四讲
02-22
视觉slam十四讲
c++学习【8】Sophus库
m0_46973820的博客
06-28 138
方法返回的是四元数的虚部，即(x, y, z, w)，而通过Eigen::Quaterniond(w, x, y, z)构造的四元数可以表示为w + xi + yj + zk。类创建了一个封装了旋转和平移的刚体变换对象。构造函数接受一个四元数对象和一个三维向量对象作为参数。：这是一个二维数组或矩阵，存储了无符号短整型(unsigned short)的值。类创建了一个四元数对象。pose.txt文件中给出了[x,y,z,Q_x,Q_y,Q_z,Q_w]则被用来表示索引操作，用于访问数组或者容器中的元素。
深蓝学院-视觉SLAM理论与实践-第十二期-第3章作业
weixin_40918019的博客
02-21 1084
群的性质 问题1：$ {Z, +} $ 是否为群？若是，验证其满足群定义；若不是，说明理由 是群，满足如下性质 封闭性：任何两个整数相加结果依然是整数 结合律：a+b+b=a+(b+c)a+b+b = a+(b+c)a+b+b=a+(b+c) 幺元：0为幺元 逆：任何一个整数与其相反数相加结果都为0 问题2：$ {N, +} $ 是否为群？若是，验证其满足群定义；若不是，说明理由 是群，满足如下性质 封闭性：任何两个整数相加结果依然是整数 结合律：a+b+b=a+(b+c)a+b+b = a+(b+c
Sophus初始化SE3d，旋转矩阵不正交
u013238941的专栏
03-13 936
点进去看是Sophus中有一个isOrthogoal的检查，没有通过Sophus的精度检查。解决方法是先将旋转矩阵转变成四元数，然后归一化，再转成旋转矩阵，这样能够保证旋转矩阵的精度，虽然有点多此一举…SLAM过程中的数值精度也非常重要，毕竟矩阵连乘，一点点数值误差会造成大量偏移。最近使用Sophus库中的SE3d类，初始化报错，报错说R is not orthogonal，传入的旋转矩阵不正交。这段代码中，旋转矩阵相乘后的输出是一个精度不高的单位矩阵（就是对角线元素是1，然后其他元素是极小量。
sophus（带模板）
10-19
适合高翔slam14讲使用。高翔的代码使用的是非模板的Sophus，安装本Sophus库后需要对高翔给的例程代码做一些简单的修改，详见我的博客：https://blog.csdn.net/weixin_44986556/article/details/109154373#t1。安装时先解压，然后在解压得到的Sophus文件夹中建立“build”文件夹，进入“build”文件夹后打开终端，用“cmake ..”和“make”完成编译。
Sophus库的安装和使用教程
热门推荐
Dongdong Bai's Blogs
09-04 2万+
本系列文章为原创，转载请注明出处。 作者：Tom Bai 邮箱： baidongdong@nudt.edu若您觉得本博文对您有帮助，请您为我点赞并关注我，以鼓励我写出更优秀的博文。谢谢！一、Sophus库简介：Eigen库是一个开源的C++线性代数库，它提供了快速的有关矩阵的线性代数运算，还包括解方程等功能。但是Eigen库提供了集合模块，但没有提供李代数的支持。一个较好的李群和李代数的库是S
【SLAM】Sophus库的超详细解析
Yngz_Miao的博客
09-08 8117
在视觉SLAM中，李群李代数是描述位姿比较常用的一种表达形式。但是，在Eigen中并不提供对它的支持，一个较好的李群和李代数的库是Sophus库，它很好的支持了SO3、so3、SE3、se3。Sophus简介 本文所对照的源码版本是2023.9.7日期，因此和网上其他的一些教程版本有些出入，但是总体相差不大。总体来说，
Sophus::SE3d 乘法 运算符 * 进行了重载 后面乘以的特征点是3x1的 ，SE3d本身的位姿矩阵是4x4的
studyvcmfc的专栏
04-26 671
Sophus::SE3d 乘法 运算符 * 进行了重载 后面乘以的特征点是3x1的 ，SE3d本身的位姿矩阵是4x4的
slam学习笔记（1）
weixin_51994127的博客
06-15 800
本文为高翔博士slam14讲学习笔记旋转向量与旋转矩阵转化：四元数表示的旋转：三维旋转可以由单位四元数来描述，四元数也具有实部和虚部，类似于二维平面中的复数用eigen包可以进行所有不同类型数之间的转化群：集合加代数运算结构，G=（A，.）李群：一种光滑连续的群李代数：由一个集合，一个数域，一个二元运算（也称为李括号）组成 g=(R^3,R,x)，构成一个李代数李代数表示在李群某一位置的导数特征李群李代数转换，指数映射与对数映射对于so，指数映射值罗德里格斯公式BCH近似： 左乘微小旋转，李群上的相乘等于李
视觉SLAM十四讲PPT
05-04
精品课程PPT分享，视觉SLAM十四讲配套PPT， 全网唯一资源
视觉SLAM十四讲配套代码
12-02
视觉SLAM十四讲配套代码
视觉SLAM十四讲-高翔 完整版
08-23
视觉SLAM十四讲-高翔 完整版
视觉SLAM学习：Sophus库中 SO(3)和SE(3)的使用方法
hhz_999的博客
08-01 1万+
视觉SLAM学习：Sophus库中 SO3和SE3的使用方法视觉SLAM学习：Sophus库中 SO(3)和SE(3)的使用方法一、SO(3)的使用方法1.1 构造1.2 李代数用法1.3 增量扰动模型的更新二、SE(3)的使用方法2.1 构造2.2 李代数用法2.3 增量扰动模型的更新 视觉SLAM学习：Sophus库中 SO(3)和SE(3)的使用方法 一、SO(3)的使用方法 1.1 构造 首先可以构造旋转矩阵或四元数： Matrix3d R=AngleAxisd(M_PI/2,Vector3d(0,
Sophus库的使用
点云兔子的博客
04-12 1204
在这个例子中，我们首先构建了一个SE(3)位姿T1，然后对其进行逆运算、乘法运算，最后将旋转矩阵和李代数相互转换。此外，还演示了如何将两个李代数相加。总的来说，Sophus库提供了一组简单而强大的工具，可以大大简化位姿运算和优化的过程。Sophus是一个用于求解李群和李代数的C++库，它提供了一组基本操作和数学函数，例如构建、转换、乘法等，可以方便地进行位姿运算和优化。
Sophus + ceres做 SE3(位姿)优化可能掉进的坑
m0_37834993的博客
09-28 2124
利用Sophus和ceres做位姿优化可能掉进的坑 这个问题和数据存储顺序及update时使用的exp操做有关 Eigen内部Quaterniond地址存储地址和初始化构造函数中参数的顺序是不一致的。 1、初始化Quaterniond(w,x,y,z)其中w是实部，x,y,z对应三个轴的虚部 但是这个Eigen内部的Quaterniond的数据存储顺序不一样，存储顺序x,y,z,w。 2、Sop...
【C++】——Stack与Queue（含优先队列（详细解读）
最新发布
m0_74092462的博客
06-09 1010
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
视觉slam十四讲-ch3
07-01
综上所述，《视觉SLAM十四讲-Ch3》通过系统地介绍了视觉SLAM技术的基本概念和实现方法，包括三维几何表示和变换、相机模型和相机姿态的原理与应用，以及特征提取与匹配的技术。这些内容为读者深入理解和掌握SLAM技术...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值