【Final Project】Kitti的双目视觉里程计（1）

最新推荐文章于 2024-06-05 10:07:43 发布
最新推荐文章于 2024-06-05 10:07:43 发布
阅读量830 收藏 1
点赞数
分类专栏： 视觉SLAM 文章标签： opencv 计算机视觉 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ASUNAchan/article/details/126878529
版权

1.从CMake文件了解整体结构

（1）前置工作

​ 0）文件结构

.
├── app
│   ├── CMakeLists.txt
│   └── run_kitti_stereo.cpp
├── CMakeLists.txt
├── cmake_modules
│   ├── FindCSparse.cmake
│   ├── FindG2O.cmake
│   └── FindGlog.cmake
├── config
│   └── default.yaml
├── include
│   └── myslam
│       ├── algorithm.h
│       ├── backend.h
│       ├── camera.h
│       ├── common_include.h
│       ├── config.h
│       ├── dataset.h
│       ├── feature.h
│       ├── frame.h
│       ├── frontend.h
│       ├── g2o_types.h
│       ├── map.h
│       ├── mappoint.h
│       ├── viewer.h
│       └── visual_odometry.h
├── src
│   ├── backend.cpp
│   ├── camera.cpp
│   ├── CMakeLists.txt
│   ├── config.cpp
│   ├── dataset.cpp
│   ├── feature.cpp
│   ├── frame.cpp
│   ├── frontend.cpp
│   ├── map.cpp
│   ├── mappoint.cpp
│   ├── viewer.cpp
│   └── visual_odometry.cpp
└── test
    ├── CMakeLists.txt
    └── test_triangulation.cpp

​ 1）系统变量

​ PROJECT_BINARY_DIR：编译发生的当前目录

​ PROJECT_SOURCE_DIR：工程所在目录

​ 2）SET指令

​ 显式定义变量

set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)

​ 3）ADD_EXECUTABLE指令

​ 4）ADD_SUBDIRECTORY指令

​ 1 ADD_SUBDIRECTOR(src bin)：源文件夹src编译的文件将保存在/build/bin下

​ 2 ADD_SUBDIRECTOR(src)：源文件夹src编译的文件将保存在/build/src下

​ 5）LIST指令

​ 告诉cmake在哪儿去找的.cmake文件

​ 6）INCLUDE_DIRECTORIES指令

​ 寻找库的头文件

​ 指定路径：

include_directories("/usr/local/include/eigen3")

​ 若使用FIND_PACKAGE：

find_package(OpenCV REQUIRED)
include_directories(${OpenCV_INCLUDE_DIRS})

​ 7）TARGET_LINK_LIBRARIES指令

​ 添加需要链接的共享库

​ 第一个参数：源文件

​ 第二个参数：所依赖的库

target_link_libraries(myslam ${THIRD_PARTY_LIBS})

​ 8）ADD_LIBRARY指令

​ 添加名为…的库，库的源文件可指定

​ 第一个参数：库的名字

​ 第二个参数：库的源文件

add_library(myslam 
        frame.cpp
        mappoint.cpp
		)

​ 9）ADD_TEST指令

​ 需要与ENABLE_TESTRING()配合使用

​ 10）FOREACH——ENDFOREACH

FOREACH (test_src ${TEST_SOURCES})
    ADD_EXECUTABLE(${test_src} ${test_src}.cpp)
    TARGET_LINK_LIBRARIES(${test_src} ${THIRD_PARTY_LIBS} myslam)
    ADD_TEST(${test_src} ${test_src})
ENDFOREACH (test_src)
（2）分析

​ 1）最外层CMakeLists.txt

​ 1 把所需要的库添加进来

​ 2 自己编写程序的头文件添加进来

​ 3 编译的中间位文件做好分组

​ 4 将添加进来的库打个包，为内层调用作准备

​ 2）/src/CMakeLists.txt

​ 1 src文件夹下存放源代码文件

​ 2 将源码文件与库链接起来

​ 3 这些文件本身也可以看成库

​ 3）/test/CMakeLists.txt

​ 测试文件

​ 4）app/CMakeLists.txt

​ 1 主程序

​ 2 调用编写的文件以及库文件

2.前置知识

（1）智能指针
shared_ptr

​ 基于引用计数的共享内存解决方案

1）基本用法

#include <iostream>
#include <new>
#include <memory>

int main()
{
    //int * x = new int(3);    
    std::shared_ptr<int> x(new int(3));
    std::cout << x.use_count() << std::endl;    //引用计数
    std::shared_ptr<int> y = x;
    std::cout << y.use_count() << std::endl;
    std::cout << x.use_count() << std::endl;
}

#include <iostream>
#include <new>
#include <memory>

std::shared_ptr<int> fun()
{
    std::shared_ptr<int> res(new int(100));
    return res;
}

int main()
{
    auto y = fun();
}
weak_ptr

​ 防止循环引用而引入的智能指针

循环引用

#include <iostream>
#include <new>
#include <memory>

struct Str
{
    std::shared_ptr<Str> m_nei;

    ~Str()
    {
        std::cout << "~Str() is called!\n";
    }
};

int main()
{
    std::shared_ptr<Str> x(new Str{});    //[x] = 1
    std::shared_ptr<Str> y(new Str{});    //[y] = 1
    x->m_nei = y;    //[y] = 2
    y->m_nei = x;    //[x] = 2
}

（1）基于 shared_ptr 构造

#include <iostream>
#include <new>
#include <memory>

struct Str
{
    std::weak_ptr<Str> m_nei;

    ~Str()
    {
        std::cout << "~Str() is called!\n";
    }
};

int main()
{
    //[]表示引用计数
    std::shared_ptr<Str> x(new Str{});    //[x] = 1
    std::shared_ptr<Str> y(new Str{});    //[y] = 1
    x->m_nei = y;    //[y] = 1
    y->m_nei = x;    //[x] = 1
}

（2）lock方法

#include <iostream>
#include <new>
#include <memory>

struct Str
{
    std::weak_ptr<Str> m_nei;

    ~Str()
    {
        std::cout << "~Str() is called!\n";
    }
};

int main()
{
    //[]表示引用计数
    std::shared_ptr<Str> x(new Str{});    //[x] = 1
    std::shared_ptr<Str> y(new Str{});    //[y] = 1
    x->m_nei = y;    //[y] = 1
    y->m_nei = x;    //[x] = 1

    if (auto ptr = x->m_nei.lock(); ptr)
    {
        std::cout << "Can access pointer\n";
    }
    else
    {
        std::cout << "Cannot access pointer\n";
    }
}
unordered_map

​ 与map类似，与 set / map 相比查找性能更好，但插入操作一些情况下会慢

1树中的每个结点是一个 std::pair

#include <iostream>
#include <map>

int main()
{
    std::map<char, int> m{{'a', 3}, {'b', 4}};
    for (auto ptr = m.begin();ptr != m.end(); ptr++)
    {
        auto p = *ptr;    //std::pair<const char, int>
        std::cout << p.first << ' ' << p.second << std::endl;
    }
    //基于range-based-for
    for (auto p : m)
    {
        std::cout << p.first << ' ' << p.second << std::endl;
    }
    //或者
    for (auto [k, v] : m)
    {
        std::cout << k << ' ' << v << std::endl;
    }
}

2键 (pair.first) 需要支持使用 < 比较大小，或者采用自定义的比较函数来引入大小关系

3访问元素： find / contains / [] / at

#include <iostream>
#include <map>

int main()
{
    std::map<int, bool> m;
    m.insert(std::pair<const int, bool>(3, true));
    auto ptr = m.find(3);
    std::cout << ptr->first << '' << ptr->second;
    std::cout << m[3] << std::endl;
}
（2）多线程及线程锁
1.多线程

（1）构造方式

​ 假如直接执行run()函数，那么由于run函数内部是一个无限循环（A），则主函数中的无限循环（B）永远无法被执行；通过新开一个线程，A与 B同时执行了。

#include <iostream>
#include  <thread>
class A
{
public:
    void run()
    {
        while (true)
        {
            std::cout << "AAAA" << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
        }

    }

};
int main()
{
    A aa;
    //aa.run();
    std::thread thr(&A::run, &aa);
    while (true)
    {
        std::cout << "BBBB" << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }
    return 0;
}

（2）join()方法

​ 阻塞当前线程直至 执行完毕再执行下面代码。

#include <iostream>
#include  <thread>
class A
{
public:
    void run()
    {
        while (true)
        {
            std::cout << "AAAA" << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
        }

    }

};
int main()
{
    A * aa = new A;
    //aa.run();
    std::thread thr(&A::run, aa);
    thr.join();
    /*
    while (true)
    {
        std::cout << "BBBB" << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }
     */
    return 0;
}
2.互斥

（1）unique_lock

3.从相机数据开始

（1）KITTI Odometry数据集
传感器安装位置

​ Kitti传感器主要包含相机（Cam0-4）、GPS/IMU、激光雷达（Velodyne Laserscanner）。本课题中只用到了相机，所以只讨论相机。

​ 在calib.txt文件中P0到P4分别对应四个相机数据，其中，P0的原点为车辆坐标系原点，P0, P1, P2, P3 分别代表对应的相机内参矩阵, 大小为 3x4：
P r e c t i = [ f u i 0 c u i − f u i b x i 0 f v i c v i 0 0 0 1 0 ] (3) P^{i}_{rect}= \left[ \begin{matrix} f^i_u & 0 & c^i_u & -f^i_ub^i_x \\ 0 & f^i_v & c^i_v & 0 \\ 0 & 0 & 1 & 0 \end{matrix} \right] \tag{3} Precti​=⎣ ⎡​fui​00​0fvi​0​cui​cvi​1​−fui​bxi​00​⎦ ⎤​(3)
​ 第四列数据 − f u i b x i -f^i_ub^i_x −fui​bxi​ 中的 b x i b^i_x bxi​ 表示此相机相对与车辆坐标系原点的距离，只有平移没有旋转。

​ 通过 b ，将四个相机的相对关系描述出来。

（2）相机模型

​ 此部分为复习，复习课本知识并思考如何融入项目之中。

1 相机内参数

​ 由KITTI数据集给出

2 相机外参数

​ 对于现实世界的空间点P，我们需要将其转换到相机坐标系：
P c = T c w P w P_c = T_{cw}P_w Pc​=Tcw​Pw​
Tips：世界坐标系不变

3 具体方法

​ 1）世界坐标系中的点P转换到相机坐标系

​ 2）相机坐标系中的点 P c P_c Pc​ 转换到像素坐标系

4 Camera类的构造

​ 相机内参数以及双目相机基线长度由数据集给出，唯一一个不确定的参数便是相机的位姿。

​ 通过数据集对相机位姿初始化：由数据集可以得到，Cam0 为世界坐标系的原点， b x i b_x^i bxi​ 为 第 i 个相机与Cam0的平移关系，旋转关系由于安装原因没有旋转。

4.基本数据结构

需要处理的数据：

​ 1 图像：双目视觉中的一对图像，可以称为一帧。

​ 2 提取特征

​ 3 通过特征计算3D位置，即路标。

（1）图像（帧）
1 构造函数

​ 通过构造函数，我认为能够迅速了解一个类。

​ 1 对于一系列的图像，可以为其编号

​ 2 该帧出现的时间

​ 3 关键帧

​ 4 相机的位姿

​ 5 读入的左右图像

Frame::Frame(long id, double time_stamp, const SE3 &pose, const Mat &left, const Mat &right)
        : id_(id), time_stamp_(time_stamp), pose_(pose), left_img_(left), right_img_(right) {}

	typedef std::shared_ptr<Frame> Ptr;

    unsigned long id_ = 0;           // id of this frame
    unsigned long keyframe_id_ = 0;  // id of key frame
    bool is_keyframe_ = false;       // 是否为关键帧
    double time_stamp_;              // 时间戳，暂不使用
    SE3 pose_;                       // Tcw 形式Pose
    std::mutex pose_mutex_;          // Pose数据锁
    cv::Mat left_img_, right_img_;   // stereo images
2 创建帧

​ 分配帧id以及关键帧id

Frame::Ptr Frame::CreateFrame() {
    static long factory_id = 0;
    Frame::Ptr new_frame(new Frame);
    new_frame->id_ = factory_id++;
    return new_frame;
}

void Frame::SetKeyFrame() {
    static long keyframe_factory_id = 0;
    is_keyframe_ = true;
    keyframe_id_ = keyframe_factory_id++;
}
3 工厂模式
Frame::Ptr Frame::CreateFrame() {
    static long factory_id = 0;
    Frame::Ptr new_frame(new Frame);
    new_frame->id_ = factory_id++;
    return new_frame;
}
（2）从帧中提取特征

​ 特征充当了一个中介，连接起3维世界中的点与图像中的点。

​ 那么最主要的信息便是从帧图像中提取到的2D位置，哪一个帧有此特征以及对应的3D路标也是需要考虑的。

    typedef std::shared_ptr<Feature> Ptr;

    std::weak_ptr<Frame> frame_;         // 持有该feature的frame
    cv::KeyPoint position_;              // 2D提取位置
    std::weak_ptr<MapPoint> map_point_;  // 关联地图点

    bool is_outlier_ = false;       // 是否为异常点
    bool is_on_left_image_ = true;  // 标识是否提在左图，false为右图

    Feature(std::shared_ptr<Frame> frame, const cv::KeyPoint &kp)
        : frame_(frame), position_(kp) {}
（3）路标点

​ 路标点最重要的信息是它的3D位置，其次是被哪些特征所观察。

1 构造函数

​ ID，3D位置

    typedef std::shared_ptr<MapPoint> Ptr;
    unsigned long id_ = 0;  // ID
    bool is_outlier_ = false;
    Vec3 pos_ = Vec3::Zero();  // Position in world
    std::mutex data_mutex_;
    int observed_times_ = 0;  // being observed by feature matching algo.
    std::list<std::weak_ptr<Feature>> observations_;

MapPoint::MapPoint(long id, Vec3 position) : id_(id), pos_(position) {}
2 创建路标点

​ 工厂模式创建路标点，可以看出与创建帧有相似性

MapPoint::Ptr MapPoint::CreateNewMappoint() {
    static long factory_id = 0;
    MapPoint::Ptr new_mappoint(new MapPoint);
    new_mappoint->id_ = factory_id++;
    return new_mappoint;
}

    Vec3 Pos() {
        std::unique_lock<std::mutex> lck(data_mutex_);
        return pos_;
    }

    void SetPos(const Vec3 &pos) {
        std::unique_lock<std::mutex> lck(data_mutex_);
        pos_ = pos;
    };
3 观察点
	void AddObservation(std::shared_ptr<Feature> feature) {
        std::unique_lock<std::mutex> lck(data_mutex_);
        observations_.push_back(feature);
        observed_times_++;
    }

void MapPoint::RemoveObservation(std::shared_ptr<Feature> feat) {
    std::unique_lock<std::mutex> lck(data_mutex_);
    for (auto iter = observations_.begin(); iter != observations_.end();
         iter++) {
        if (iter->lock() == feat) {
            observations_.erase(iter);      //erase() 删除
            feat->map_point_.reset();
            observed_times_--;
            break;
        }
    }
}
（4）地图类

​ 为了实际持有Frame和MapPoint对象，定义地图类。

1 成员变量
	typedef std::shared_ptr<Map> Ptr;
    typedef std::unordered_map<unsigned long, MapPoint::Ptr> LandmarksType;
    typedef std::unordered_map<unsigned long, Frame::Ptr> KeyframesType;

    std::mutex data_mutex_;

    LandmarksType landmarks_;         // all landmarks
    LandmarksType active_landmarks_;  // active landmarks
    KeyframesType keyframes_;         // all key-frames
    KeyframesType active_keyframes_;  // all key-frames

    Frame::Ptr current_frame_ = nullptr;

    // settings
    int num_active_keyframes_ = 7;  // 激活的关键帧数量
2 实现功能
    /// 增加一个关键帧
    void InsertKeyFrame(Frame::Ptr frame);
    /// 增加一个地图顶点
    void InsertMapPoint(MapPoint::Ptr map_point);

    /// 获取所有地图点
    LandmarksType GetAllMapPoints() {
        std::unique_lock<std::mutex> lck(data_mutex_);
        return landmarks_;
    }
    /// 获取所有关键帧
    KeyframesType GetAllKeyFrames() {
        std::unique_lock<std::mutex> lck(data_mutex_);
        return keyframes_;
    }

    /// 获取激活地图点
    LandmarksType GetActiveMapPoints() {
        std::unique_lock<std::mutex> lck(data_mutex_);
        return active_landmarks_;
    }

    /// 获取激活关键帧
    KeyframesType GetActiveKeyFrames() {
        std::unique_lock<std::mutex> lck(data_mutex_);
        return active_keyframes_;
    }

void Map::InsertKeyFrame(Frame::Ptr frame) {
    current_frame_ = frame;
    if (keyframes_.find(frame->keyframe_id_) == keyframes_.end()) {
        keyframes_.insert(make_pair(frame->keyframe_id_, frame));
        active_keyframes_.insert(make_pair(frame->keyframe_id_, frame));
    } else {
        keyframes_[frame->keyframe_id_] = frame;
        active_keyframes_[frame->keyframe_id_] = frame;
    }

    if (active_keyframes_.size() > num_active_keyframes_) {
        RemoveOldKeyframe();
    }
}
/*
	keyframes_.end():指向map容器最后一个的下一个
	keyframes_.find():通过键查找对象是否在容器里，若不存在，就指向end
	上述if语句判断传入帧的id是否在容器中，若在，就用新的把旧的替换掉；若不存在，就添加进去。
*/

void Map::InsertMapPoint(MapPoint::Ptr map_point) 	//与添加关键帧一样
{
    if (landmarks_.find(map_point->id_) == landmarks_.end()) {
        landmarks_.insert(make_pair(map_point->id_, map_point));
        active_landmarks_.insert(make_pair(map_point->id_, map_point));
    } else {
        landmarks_[map_point->id_] = map_point;
        active_landmarks_[map_point->id_] = map_point;
    }
}


void Map::RemoveOldKeyframe() {
    if (current_frame_ == nullptr) return;
    // 寻找与当前帧最近与最远的两个关键帧
    double max_dis = 0, min_dis = 9999;
    double max_kf_id = 0, min_kf_id = 0;
    auto Twc = current_frame_->Pose().inverse();
    for (auto& kf : active_keyframes_) {
        if (kf.second == current_frame_) continue;
        auto dis = (kf.second->Pose() * Twc).log().norm();
        if (dis > max_dis) {
            max_dis = dis;
            max_kf_id = kf.first;
        }
        if (dis < min_dis) {
            min_dis = dis;
            min_kf_id = kf.first;
        }
    }

    const double min_dis_th = 0.2;  // 最近阈值
    Frame::Ptr frame_to_remove = nullptr;
    if (min_dis < min_dis_th) {
        // 如果存在很近的帧，优先删掉最近的
        frame_to_remove = keyframes_.at(min_kf_id);
    } else {
        // 删掉最远的
        frame_to_remove = keyframes_.at(max_kf_id);
    }

    LOG(INFO) << "remove keyframe " << frame_to_remove->keyframe_id_;
    // remove keyframe and landmark observation
    active_keyframes_.erase(frame_to_remove->keyframe_id_);
    for (auto feat : frame_to_remove->features_left_) {
        auto mp = feat->map_point_.lock();
        if (mp) {
            mp->RemoveObservation(feat);
        }
    }
    for (auto feat : frame_to_remove->features_right_) {
        if (feat == nullptr) continue;
        auto mp = feat->map_point_.lock();
        if (mp) {
            mp->RemoveObservation(feat);
        }
    }

    CleanMap();
}

void Map::CleanMap() {
    int cnt_landmark_removed = 0;
    for (auto iter = active_landmarks_.begin();
         iter != active_landmarks_.end();) {
        if (iter->second->observed_times_ == 0) {
            iter = active_landmarks_.erase(iter);
            cnt_landmark_removed++;
        } else {
            ++iter;
        }
    }
    LOG(INFO) << "Removed " << cnt_landmark_removed << " active landmarks";
}

感受：代码读下来只能说需要时间去理解，脑子里隐约有了个关于框架，基本的参数以及参数的功能有了一定的了解，但是对于一些辅助参数比如各种 ID，时间戳等在自己编写程序的时候能够思考加上，以及选用什么样的容器也是需要思考的地方。

花舞の街道
关注
专栏目录
视觉SLAM入门 -- 学习笔记 - Part 9 Kitti 的双目视觉里程计
～勿据散客～的博客
11-23 834
Kitti 的Odometry 提供了左右双目的视觉图像（以及激光，但本作业不使用激光数据），并提供了标定信息。它一共含有若干个Sequence，其中一部分Sequence 的真实轨迹是开放的，另一部分则是隐藏的，作为测试使用。在Kitti 官网可以上传你对测试部分的轨迹估计，系统会计算与真实轨迹的差异，并给出评分。 现在我们已经介绍了所有关于视觉SLAM 方面的内容，你可以基于已有算法，实现一个双目的视觉里程计了。Kitti 官网odometry 分类下提供了双目相机的所有信息。请你根据已学知识，实现双目
visual_odometry:在KITTI数据集上进行视觉里程计，实现了单眼2D-2D和立体声2D-3D
05-16
视觉里程表 这是在上的OpenCV 3.4实现。 方法 2D-2D单眼VO和2D-3D立体声VO 实施细节 编译 在2目录中： mkdir build cd build cmake .. make 跑步 编译后，直接在构建中单核细胞增多症 ./vo [sequence ID] [dataset directory] 立体声 ./vo [sequence ID] [max frame] [optimize frame] [dataset directory] 表现
【Final Project】Kitti的双目视觉里程计（3）前端及整体过程理解
ASUNAchan的博客
11-22 840
SLAM
【Final Project】Kitti的双目视觉里程计（2）重读
ASUNAchan的博客
11-18 659
无聊总结，忘了的时候查看
图像为什么能相减
saltriver的专栏
12-23 4899
前面提到，我们可以把图像看作一个函数，函数和函数之间是可以相加的。 f(x,y)=I1(x,y)+I2(x,y)f(x, y) = I_1(x, y) + I_2(x, y) 那么，既然函数可以相加，函数也是可以相减的。所以，图像之间是不是也能相减呢？答案是肯定的。我们知道10-8=2，表示8和10之间的差别是相差2。那么图像相减同样是用于表示图像之间的差别。在冈萨雷斯的《数字图像处理》书中，介
cvNew_KITTI_KITTI数据集_视觉里程计C++实现_
10-03
《视觉里程计C++实现基于KITTI数据集的探索与实践》 在计算机视觉领域，视觉里程计（Visual Odometry, VO）是一项重要的技术，它通过连续分析图像序列来估计相机的运动轨迹。本篇文章将深入探讨如何使用C++语言在...
基于点线特征鲁棒性评估的双目视觉里程计_荣燊1
08-03
【基于点线特征鲁棒性评估的双目视觉里程计】是针对自动化领域的同步定位与地图构建（SLAM）技术中的一种改进方案。SLAM 是自动驾驶、无人机控制和太空机器人等应用的关键技术，它需要通过视觉传感器来实时估计设备...
一种双目直接法视觉里程计.docx
02-23
本文提出了一种使用双目相机的直接法视觉里程计，使用双目影像对与时序影像对之间的光度误差联合优化关键帧的位置与姿态、相机内参数、地图点坐标，并在车载道路基准数据集KITTI上进行测试，获得了良好的效果。...
【泡泡图灵智库】一种用于快速自主飞行且非常鲁棒的双目视觉惯性里程计方法（ICRA-39）
诗筱涵的博客
07-17 323
这就是我Github看到的那个 转载自：https://mp.weixin.qq.com/s/s-MHNBKRPOaxOcwsasBa7Q 【泡泡图灵智库】一种用于快速自主飞行且非常鲁棒的双目视觉惯性里程计方法（ICRA-39） 原创 paopaoslam 泡泡机器人SLAM 2018-09-04 泡泡图灵智库，带你精读机器人顶级会议文章 标题：Robust Stereo Visual Inertial Odometry for Fast Autonomous Flight 作者：Ke S.
里程计及基于双目视觉的视觉里程计(stereo visual odometry)
热门推荐
J10527的博客
10-17 1万+
里程计在slam算法中扮演的作用不言而喻，通常里程计可以分为轮子编码器的里程计(wheel odometry)和视觉里程计(visual odometry)。而视觉里程计又可分为基于单目的视觉里程计(mono-camera odometry)和基于双目的视觉里程计(stereo odometry)。 关于轮子编码器的里程计，当路面水平时精度尚可，否则误差越来越大，此时有基于IMU等传感器
SLAM十四讲、双目视觉里程计、麻省理工《算法推导》、邹丹平教授视频、计算机视觉 、区块链
03-28
SLAM十四讲、双目视觉里程计、麻省理工《算法推导》、邹丹平教授视频、计算机视觉 、区块链以及其他相关的链接
视觉里程计
04-15
视觉里程计（visual odometry）
基于双目事件相机的视觉里程计
qq_29462849的博客
09-22 221
点击上方“计算机视觉工坊”，选择“星标”干货第一时间送达论文标题：Zhou, Yi,Guillermo Gallego, and Shaojie Shen. "Event-bas...
港科大开源 | 基于事件的双目视觉里程计
3D视觉工坊
12-02 1286
点击上方“3D视觉工坊”，选择“星标”干货第一时间送达1摘要本文提出了一种双目事件相机的视觉里程计方法.我们的系统遵循并行跟踪和建图的方法,建图模块以概率的方式融合来自多个局部视点(通过...
KITTI SOTA | SOFT2：视觉里程计新方案！
CV_Autobot的博客
04-17 938
作者|派派星 编辑| CVHub点击下方卡片，关注“自动驾驶之心”公众号ADAS巨卷干货，即可获取点击进入→自动驾驶之心【SLAM】技术交流群后台回复【SLAM综述】获取视觉SLAM、激光SLAM、RGBD-SLAM等多篇综述！Paper: https://arxiv.org/pdf/2109.03462.pdfPaper: https://lamor.fer.hr/images/5003...
一个简单的视觉里程计实现(2)
子墨的专栏
11-15 6389
前面讲述了特征提取，后期可以尝试orb_slam中采用orb，对特征加入方向信息，使得特征具备旋转不变性。 特征跟踪 特征提取是一个比较耗时的操作，即使使用了FAST特征检测，而且都是使用特征提取之后要进行特征匹配，通过RANSAC等方法进行特征提纯等操作，然后由于两帧之间时间间隔较短，完全可以采用跟踪的方法来预测下一帧的特征点。 我们采用KLT跟踪算法,具体算法的介绍可以参考原论文或者可以
【探索视觉定位新维度】KITTI里程估计评估工具深度解析与应用指南
最新发布
gitblog_00076的博客
06-05 460
【探索视觉定位新维度】KITTI里程估计评估工具深度解析与应用指南 项目地址:https://gitcode.com/LeoQLi/KITTI_odometry_evaluation_tool 在自动驾驶和机器人技术的浪潮中，精准的定位能力是至关重要的基石。今天，我们要向大家隆重介绍一个强大且易于使用的开源神器——KITTI里程估计评估工具，它专为那些致力于提高视觉里程计算精度的研究者和开发者们量...
为什么自己编的两帧之间视觉里程计用KITTI数据集评估，结果会如此得差呢？
YMWM_的博客
03-07 1195
背景介绍 学习了一段时间的SLAM，感觉对它的原理有了一定的了解，就想编写一个两帧之间的运动评估的demo，在这个demo中没有后端优化、建图和回环检测，只有两帧之间的运动估计。大概思路：采用双目相机，利用SGBM算法得到左目的视差图，进而恢复左目的深度信息，前后帧之间采用ORB特征匹配，采用RANSAC算法做误匹配剔除，采用奇异值分解的ICP方法来估计运动。 代码写好了之后，利用KITTI数据集...
VOLDOR：基于光流恢复的视觉里程计方法
"本文介绍了一种名为VOLDOR (Visual Odometry with Log-logistic Dense Optical Flow Recovery) 的新型视觉里程计方法，该方法利用密集光流恢复技术来提高定位精度。VOLDOR采用概率模型来定义问题，并通过广义期望...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值