vSLAM 使用二进制词典优化加载速度

已于 2022-08-11 09:01:45 修改
阅读量389 收藏 3
点赞数 3
分类专栏： vSLAM 文章标签： 计算机视觉 人工智能
于 2022-07-21 11:40:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenzhe78/article/details/125888013
版权

一 DBoW2

        ORB-SLAM2和ORB-SLAM3使用的是DBoW2，DBoW2.h中只封装了brief特征（VINS原版使用）和ORB特征，对应两种字典和数据库。

        TemplatedVocabulary.h只封装了brief和ORB特征的字典的save和load。ORB特征（描述子cv::Mat是CV_8U类型，描述子size为1*32）用txt格式存储，brief特征用bin格式存储，没有封装SuperPoint特征（描述子cv::Mat是CV_32F类型，描述子size为1*256）需要自己改写。

#define CV_8U   0
#define CV_8S   1
#define CV_16U  2
#define CV_16S  3
#define CV_32S  4
#define CV_32F  5
#define CV_64F  6
#define CV_USRTYPE1 7

/opt/ros/kinetic/include/opencv-3.3.1-dev/opencv2/core/hal/interface.h

1）ORB特征

        DBOW2中TemplatedVocabulary.h已经提供txt格式：

/**
 * Loads the vocabulary from a text file
 * @param filename
 */
bool loadFromTextFile(const std::string &filename);

/**
 * Saves the vocabulary into a text file
 * @param filename
 */
void saveToTextFile(const std::string &filename) const;

        GitHub - poine/ORB_SLAM2对其改写为binary格式：

template<class TDescriptor, class F>
bool TemplatedVocabulary<TDescriptor,F>::loadFromBinaryFile(const std::string &filename) {
  fstream f;
  f.open(filename.c_str(), ios_base::in|ios::binary);
  unsigned int nb_nodes, size_node;
  f.read((char*)&nb_nodes, sizeof(nb_nodes));
  f.read((char*)&size_node, sizeof(size_node));
  f.read((char*)&m_k, sizeof(m_k));
  f.read((char*)&m_L, sizeof(m_L));
  f.read((char*)&m_scoring, sizeof(m_scoring));
  f.read((char*)&m_weighting, sizeof(m_weighting));
  createScoringObject();
  
  m_words.clear();
  m_words.reserve(pow((double)m_k, (double)m_L + 1));
  m_nodes.clear();
  m_nodes.resize(nb_nodes+1);
  m_nodes[0].id = 0;
  char buf[size_node]; int nid = 1;
  while (!f.eof()) {
   f.read(buf, size_node);
   m_nodes[nid].id = nid;
   // FIXME
   const int* ptr=(int*)buf;
   m_nodes[nid].parent = *ptr;
   //m_nodes[nid].parent = *(const int*)buf;
   m_nodes[m_nodes[nid].parent].children.push_back(nid);
   m_nodes[nid].descriptor = cv::Mat(1, F::L, CV_8U);
   memcpy(m_nodes[nid].descriptor.data, buf+4, F::L);
   m_nodes[nid].weight = *(float*)(buf+4+F::L);
   if (buf[8+F::L]) { // is leaf
     int wid = m_words.size();
     m_words.resize(wid+1);
     m_nodes[nid].word_id = wid;
     m_words[wid] = &m_nodes[nid];
   }
   else
     m_nodes[nid].children.reserve(m_k);
   nid+=1;
  }
  f.close();
  return true;
}


// --------------------------------------------------------------------------

template<class TDescriptor, class F>
void TemplatedVocabulary<TDescriptor,F>::saveToBinaryFile(const std::string &filename) const {
  fstream f;
  f.open(filename.c_str(), ios_base::out|ios::binary);
  unsigned int nb_nodes = m_nodes.size();
  float _weight;
  unsigned int size_node = sizeof(m_nodes[0].parent) + F::L*sizeof(char) + sizeof(_weight) + sizeof(bool);
  f.write((char*)&nb_nodes, sizeof(nb_nodes));
  f.write((char*)&size_node, sizeof(size_node));
  f.write((char*)&m_k, sizeof(m_k));
  f.write((char*)&m_L, sizeof(m_L));
  f.write((char*)&m_scoring, sizeof(m_scoring));
  f.write((char*)&m_weighting, sizeof(m_weighting));
  for(size_t i=1; i<nb_nodes;i++) {
   const Node& node = m_nodes[i];
   f.write((char*)&node.parent, sizeof(node.parent));
   f.write((char*)node.descriptor.data, F::L);
   _weight = node.weight; f.write((char*)&_weight, sizeof(_weight));
   bool is_leaf = node.isLeaf(); f.write((char*)&is_leaf, sizeof(is_leaf)); // i put this one at the end for alignement....
  }
  f.close();
}

        具体用法在tools/bin_vocabulary.cc中：

#include "ORBVocabulary.h"
using namespace std;

bool load_as_text(ORB_SLAM2::ORBVocabulary* voc, const std::string infile) {
  clock_t tStart = clock();
  bool res = voc->loadFromTextFile(infile);
  printf("Loading fom text: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
  return res;
}

void load_as_xml(ORB_SLAM2::ORBVocabulary* voc, const std::string infile) {
  clock_t tStart = clock();
  voc->load(infile);
  printf("Loading fom xml: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
}

void load_as_binary(ORB_SLAM2::ORBVocabulary* voc, const std::string infile) {
  clock_t tStart = clock();
  voc->loadFromBinaryFile(infile);
  printf("Loading fom binary: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
}

void save_as_xml(ORB_SLAM2::ORBVocabulary* voc, const std::string outfile) {
  clock_t tStart = clock();
  voc->save(outfile);
  printf("Saving as xml: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
}

void save_as_text(ORB_SLAM2::ORBVocabulary* voc, const std::string outfile) {
  clock_t tStart = clock();
  voc->saveToTextFile(outfile);
  printf("Saving as text: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
}

void save_as_binary(ORB_SLAM2::ORBVocabulary* voc, const std::string outfile) {
  clock_t tStart = clock();
  voc->saveToBinaryFile(outfile);
  printf("Saving as binary: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC);
}


int main(int argc, char **argv) {
  cout << "BoW load/save benchmark" << endl;
  ORB_SLAM2::ORBVocabulary* voc = new ORB_SLAM2::ORBVocabulary();

  load_as_text(voc, "Vocabulary/ORBvoc.txt");
  save_as_binary(voc, "Vocabulary/ORBvoc.bin");

  return 0;
}

2）SuperPoint特征

       txt格式可以参考ORB改写：

static int descriptor_length_in_bytes = 256;  // ORB: 32;

void fromString(cv::Mat &a, const std::string &s) {
  a.create(1, descriptor_length_in_bytes, CV_32F);
  float *p = a.ptr<float>();

  std::stringstream ss(s);
  for(int i = 0; i < a.cols; ++i, ++p) {
    float n;
    ss >> n;

    if(!ss.fail())
      *p = n;
  }
}

std::string toString(const cv::Mat &a) {
  std::stringstream ss;

  const float *p = a.ptr<float>();
  for(int i = 0; i < a.cols; ++i, ++p)
    ss << *p << " ";

  return ss.str();
}

bool Vocabulary::loadFromTextFile(const std::string &filename) {
  std::ifstream f;
  f.open(filename.c_str());

  if(f.eof())
    return false;

  m_words.clear();
  m_nodes.clear();

  std::string s;
  getline(f,s);
  std::stringstream ss;
  ss << s;
  ss >> m_k;
  ss >> m_L;
  int n1, n2;
  ss >> n1;
  ss >> n2;

  if(m_k<0 || m_k>20 || m_L<1 || m_L>10 || n1<0 || n1>5 || n2<0 || n2>3) {
    std::cerr << "Vocabulary loading failure: This is not a correct text file!" << std::endl;
    return false;
  }

  m_scoring = (ScoringType)n1;
  m_weighting = (WeightingType)n2;
  createScoringObject();

  // nodes
  int expected_nodes =
      (int)((pow((double)m_k, (double)m_L + 1) - 1)/(m_k - 1));
  m_nodes.reserve(expected_nodes);

  m_words.reserve(pow((double)m_k, (double)m_L + 1));

  m_nodes.resize(1);
  m_nodes[0].id = 0;
  while(!f.eof()) {
    std::string snode;
    getline(f,snode);
    std::stringstream ssnode;
    ssnode << snode;

    int nid = m_nodes.size();
    m_nodes.resize(m_nodes.size()+1);
    m_nodes[nid].id = nid;

    int pid ;
    ssnode >> pid;
    m_nodes[nid].parent = pid;
    m_nodes[pid].children.push_back(nid);

    int nIsLeaf;
    ssnode >> nIsLeaf;

    std::stringstream ssd;
    for(int iD=0;iD<descriptor_length_in_bytes;iD++) {
      std::string sElement;
      ssnode >> sElement;
      ssd << sElement << " ";
    }
    fromString(m_nodes[nid].descriptor, ssd.str());

    ssnode >> m_nodes[nid].weight;

    if(nIsLeaf>0) {
      int wid = m_words.size();
      m_words.resize(wid+1);

      m_nodes[nid].word_id = wid;
      m_words[wid] = &m_nodes[nid];
    } else {
      m_nodes[nid].children.reserve(m_k);
    }
  }

  std::cout << "nodes size: " << m_nodes.size()
            << ", world size: " << m_words.size()
            << ", descriptor type: " << m_nodes.back().descriptor.type()
            << ", descriptor size: " << m_nodes.back().descriptor.size << std::endl;
  std::cout << "descriptor: "<< cv::format(m_nodes.back().descriptor, cv::Formatter::FMT_C) << std::endl;
  return true;
}
 

void Vocabulary::saveToTextFile(const std::string &filename) const {
  std::fstream f;
  f.open(filename.c_str(),std::ios_base::out);
  f << m_k << " " << m_L << " " << " " << m_scoring << " " << m_weighting << std::endl;

  for(size_t i=1; i<m_nodes.size();i++) {
    const Node& node = m_nodes[i];

    f << node.parent << " ";
    if(node.isLeaf())
      f << 1 << " ";
    else
      f << 0 << " ";

    f << toString(node.descriptor) << " " << (double)node.weight << std::endl;
  }

  f.close();
}

        二进制加速参考GitHub - poine/ORB_SLAM2改写，目前还有点小问题。

bool Vocabulary::loadFromBinaryFile(const std::string &filename) {
  std::fstream f;
  f.open(filename.c_str(), std::ios_base::in | std::ios::binary);
  unsigned int nb_nodes, size_node;
  f.read((char*)&nb_nodes, sizeof(nb_nodes));
  f.read((char*)&size_node, sizeof(size_node));
  f.read((char*)&m_k, sizeof(m_k));
  f.read((char*)&m_L, sizeof(m_L));
  f.read((char*)&m_scoring, sizeof(m_scoring));
  f.read((char*)&m_weighting, sizeof(m_weighting));
  createScoringObject();

  m_words.clear();
  m_words.reserve(pow((double)m_k, (double)m_L + 1));
  m_nodes.clear();
  m_nodes.resize(nb_nodes+1);
  m_nodes[0].id = 0;
  char buf[size_node]; int nid = 1;
  while (!f.eof()) {
    f.read(buf, size_node);
    std::cout << "buf: " << buf << std::endl;
    m_nodes[nid].id = nid;
    // FIXME
    const float* ptr=(float*)buf;
    m_nodes[nid].parent = *ptr;
    //m_nodes[nid].parent = *(const int*)buf;
    m_nodes[m_nodes[nid].parent].children.push_back(nid);
    memcpy(m_nodes[nid].descriptor.data, buf+4, sizeof(float)*descriptor_length_in_bytes);
//    memcpy(m_nodes[nid].descriptor.data, buf+4, descriptor_length_in_bytes);
    m_nodes[nid].weight = *(float*)(buf+4+sizeof(float)*descriptor_length_in_bytes);
    if (buf[8+sizeof(float)*descriptor_length_in_bytes]) { // is leaf
      int wid = m_words.size();
      m_words.resize(wid+1);
      m_nodes[nid].word_id = wid;
      m_words[wid] = &m_nodes[nid];
    }
    else
      m_nodes[nid].children.reserve(m_k);
    nid+=1;
  }
  f.close();

  std::cout << "nodes size: " << m_nodes.size()
            << ", world size: " << m_words.size()
            << ", descriptor type: " << m_nodes.back().descriptor.type()
            << ", descriptor size: " << m_nodes.back().descriptor.size << std::endl;
  std::cout << "descriptor: "<< cv::format(m_nodes.back().descriptor, cv::Formatter::FMT_C) << std::endl;
  return true;
}

void Vocabulary::saveToBinaryFile(const std::string &filename) const {
  std::fstream f;
  f.open(filename.c_str(), std::ios_base::out | std::ios::binary);
  unsigned int nb_nodes = m_nodes.size();
  float _weight;
  unsigned int size_node = sizeof(m_nodes[0].parent) + descriptor_length_in_bytes*sizeof(float) + sizeof(_weight) + sizeof(bool);
  f.write((char*)&nb_nodes, sizeof(nb_nodes));
  f.write((char*)&size_node, sizeof(size_node));
  f.write((char*)&m_k, sizeof(m_k));
  f.write((char*)&m_L, sizeof(m_L));
  f.write((char*)&m_scoring, sizeof(m_scoring));
  f.write((char*)&m_weighting, sizeof(m_weighting));
  for(size_t i=1; i<nb_nodes;i++) {
    const Node& node = m_nodes[i];
    f.write((char*)&node.parent, sizeof(node.parent));
    f.write((char*)&node.descriptor.data, descriptor_length_in_bytes*sizeof(float));
    _weight = node.weight; f.write((char*)&_weight, sizeof(_weight));
    bool is_leaf = node.isLeaf(); f.write((char*)&is_leaf, sizeof(is_leaf)); // i put this one at the end for alignement....
  }
  f.close();
}

二 DBoW3

        不用定义不同特征的字典模板类，调用dbow3/Vocabulary.cpp中区分load和save函数，通过后缀和是否为二进制类型的文件进行加载和保存字典。

1）txt格式，实际会调用

/** 
 * Saves the vocabulary to a file storage structure
 * @param fn node in file storage
 */
virtual void save(cv::FileStorage &fs, 
  const std::string &name = "vocabulary") const;

/**
 * Loads the vocabulary from a file storage node
 * @param fn first node
 * @param subname name of the child node of fn where the tree is stored.
 *   If not given, the fn node is used instead
 */  
virtual void load(const cv::FileStorage &fs, 
  const std::string &name = "vocabulary");

        其中的不同特征类型对应的不同描述子格式用dbow3/DescManip.cpp中的

std::string DescManip::toString(const cv::Mat &a)
{
    stringstream ss;
    //introduce a magic value to distinguish from DBOw2
    ss<<"dbw3 ";
    //save size and type


    ss <<a.type()<<" "<<a.cols<<" ";

    if (a.type()==CV_8U){
        const unsigned char *p = a.ptr<unsigned char>();
        for(int i = 0; i < a.cols; ++i, ++p)
            ss << (int)*p << " ";
    }else{

        const float *p = a.ptr<float>();
        for(int i = 0; i < a.cols; ++i, ++p)
            ss <<  *p << " ";

    }

    return ss.str();
}

// --------------------------------------------------------------------------
  
void DescManip::fromString(cv::Mat &a, const std::string &s)
{

    //check if the dbow3 is present
    string ss_aux;ss_aux.reserve(10);
    for(size_t i=0;i<10 && i<s.size();i++)
        ss_aux.push_back(s[i]);
    if(ss_aux.find("dbw3")==std::string::npos){//is dbow2
        //READ UNTIL END
        stringstream ss(s);
        int val;
        vector<uchar> data;data.reserve(100);
        while( ss>>val) data.push_back(val);
        //copy to a
        a.create(1,data.size(),CV_8UC1);
        memcpy(a.ptr<char>(0),&data[0],data.size());
    }
    else {
        char szSign[10];
        int type,cols;
        stringstream ss(s);
        ss >> szSign >> type >> cols;
        a.create(1,  cols, type);
        if(type==CV_8UC1){
            unsigned char *p = a.ptr<unsigned char>();
            int n;
            for(int i = 0; i <  a.cols; ++i, ++p)
                if ( ss >> n) *p = (unsigned char)n;
        }
        else{
            float *p = a.ptr<float>();
            for(int i = 0; i <  a.cols; ++i, ++p)
                if ( !(ss >> *p))cerr<<"Error reading. Unexpected EOF. DescManip::fromString"<<endl;
        }

    }

}

2）二进制格式，实际会调用

void toStream(  std::ostream &str, bool compressed=true) const throw(/*std::exception*/);

void fromStream(  std::istream &str )   throw(/*std::exception*/);其

        其中的不同特征类型对应的不同描述子格式用dbow3/DescManip.cpp中的

void DescManip::toStream(const cv::Mat &m,std::ostream &str){
    assert(m.rows==1 || m.isContinuous());
    int type=m.type();
    int cols=m.cols;
    int rows=m.rows;
    str.write((char*)&cols,sizeof(cols));
    str.write((char*)&rows,sizeof(rows));
    str.write((char*)&type,sizeof(type));
    str.write((char*)m.ptr<char>(0),m.elemSize()*m.cols);
}

void DescManip::fromStream(cv::Mat &m,std::istream &str){
    int type,cols,rows;
    str.read((char*)&cols,sizeof(cols));
    str.read((char*)&rows,sizeof(rows));
    str.read((char*)&type,sizeof(type));
    m.create(rows,cols,type);
    str.read((char*)m.ptr<char>(0),m.elemSize()*m.cols);
}

三 实验效果

改前：

改后：

四 代码参考：

GitHub - poine/ORB_SLAM2: Real-Time SLAM for Monocular, Stereo and RGB-D Cameras, with Loop Detection and Relocalization Capabilities

commit 4122702ced85b20bd458d0e74624b9610c19f8cc

added binary version of vocabulary to speedup ORB_SLAM2 start

五 工程实例：

https://zhuanlan.zhihu.com/p/20589372

https://zhuanlan.zhihu.com/p/20596486

szhiter
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
ORB SLAM3加载Vocabulary更快ORBvoc.bin
qq_41861406的博客
08-02 580
将ORBvoc.bin拷贝到Vocabulary文件夹下，ORBvoc.bin百度云盘下载地址 密码idr0,记得解压缩。
ORB-SLAM2源码学习（七）——DBoW2词袋模型
potxxx的博客
02-23 3167
  ORB-SLAM2里使用词袋模型来做重定向与回环检测，使用的是第三方库DBoW2。 首先，有一个离线词袋ORBvoc.txt文件（ORB-SLAM2作者提供了一个他们训练好的词典），一般这个称之为词典，为了快速查询，以空间换时间建立了一个d层的K叉树来保存词典，树的叶子节点包含了每个单词及在词典里的权重。 词典的加载 //在System对象的初始化中 mpVocabulary...
两个ROS接口Mono_inertial和Stereo_inertial被添加到ORB-SLAM3中。 以更快的二进制方式修改了加载词汇表。-C/C++开发
05-27
Two ROS interfaces Mono_inertial and Stereo_inertial were added to the ORB-SLAM3. Modified the loading vocabulary in a faster binary way. ORB_SLAM3-ROS-Interface Two ROS interfaces Mono_inertial and Stereo_inertial were added to the ORB-SLAM3. Modified the loading vocabulary in a faster binary way. 增加了两个ROS接口，单目IMU和双目IMU，替换了词典为二进制格式，加载速度更快。 Command Mono_inertial: rosrun ORB_SLAM3 Mono_inertial /YOUR_PATH/ORBvoc.bin /YOUR_PATH/EuRoC.yaml Stereo_inertial: rosrun ORB_SLAM3 Stereo_inertial /YOUR_PAT
DBoW2加载训练好的二进制格式ORB特征词典及测试
Z5122的博客
12-01 2205
为了利用ORB-SLAM2中提供的二进制格式的ORB词典，根据开源，稍作修改，这里给出自己编译后的lib文件及include文件，对于自己新建的项目，链接到上面的两个文件即可。 #include &amp;quot;stdafx.h&amp;quot; #include &amp;amp;lt;BowVector.h&amp;amp;gt; #include &amp;amp;lt;TemplatedVocabulary.h&amp;amp;gt; #
vslam VINS-Mono介绍 ，PPT格式，主要为vslam与vins框架介绍，下载可直接编辑使用
09-07
VSLAM（Visual Simultaneous Localization and Mapping）即视觉同时定位和建图，是指如何使用相机解决定位和建图问题。当使用相机作为传感器时，我们需要根据一系列连续运动的图像，从中推断相机的运动以及周围环境...
SLAM-良好线切割-转为PL-SLAM等线辅助VSLAM设计的增强模块-辅助姿态优化-优质项目实战.zip
最新发布
03-17
在这个名为"SLAM-良好线切割-转为PL-SLAM等线辅助VSLAM设计的增强模块-辅助姿态优化-优质项目实战"的压缩包中，我们看到的是一个针对SLAM算法进行优化和实践的项目，特别是关注了线特征的提取、PL-SLAM方法以及姿态...
良好的线切割在行辅助VO/VSLAM中的精确姿势优化中的应用
本文解决了行辅助VO/VSLAM中的问题：使用不可靠的3D线输入精确地解决最小二乘姿态优化。我们提出的解决方案是良好的线切割，从每条3D线中提取信息量最大的子段，用于姿势优化配方。通过研究基于直线的最小二乘问题中...
stella-vslam所有依赖包
03-30
在VSLAM中，Eigen被用来处理几何变换、姿态估计和优化问题。 3. **g2o**（Graph Optimization）：这是一个轻量级的C++库，用于图优化问题，特别适用于SLAM中的最小二乘问题。它可以处理各种类型的边，如位姿图优化...
基于特征点法和直接法VSLAM的研究
04-30
基于视觉的同时定位和建图（VSLAM）分为前端和后端，前端包括视觉里程计和回环检测，后端包括后端优化和建图。按照估计相机运动的不同方式，将VSLAM分为特征点法和直接法，首先从这两个方面对前端进行综述，阐述其中...
ORB_SLAM2中的字典DBow
Bluenapa的博客
02-16 2854
参考： https://www.jianshu.com/p/cfcdf12a3bb6 （创建DBow离线词典用于ORB SLAM2） https://github.com/dorian3d?tab=overview&amp;from=2018-12-01&amp;to=2018-12-31（DBOW作者的github）   前言 无论是DBow2,还是DBow3，它们创建的字典文件的都是....
肺炎期间的科研实验之--0301 词袋模型DBoW3跳坑！！！！
hongyunzhi92的博客
03-07 640
#include "DBoW3/DBoW3.h" //使用了BOW这个库 #include <opencv2/core/core.hpp> #include <opencv2/highgui/highgui.hpp> #include <opencv2/features2d/features2d.hpp> #include <iostream> #i...
从ORB-SLAM2的源码工程中学习C++编程——关键帧数据库
zhaodeming000的博客
04-04 552
关键帧数据库 构建关键帧数据库，可以联系链表等常用数据结构的构建过程：创建、增加元素、删除元素、清理。 首先需要明确数据存储的数据类型：以关键帧作为数据库的元素。 这个地方需要理解两个概念：单词（词库）和关键帧。 单词（词库）：预先构建好的。 ...
VINS-Mono中的DBoW2关键代码注释
yys2324826380的博客
04-12 1112
VINS-Mono中的DBoW2关键代码注释 在阅读VINS-Mono源码时对DBoW2中代码顺手做的注释，怕以后会忘记，在这里记录一下，注释有不当之处，望各位大神看到后多多指点。理论参考高翔的《视觉SLAM十四讲》第12章的内容。 ...
ORB SLAM3 使用二进制文件 ORBvoc.bin 加载Vocabulary
weixin_62952541的博客
11-16 391
运行时，需要把原来加载词袋命令 ./Vocabulary/ORBvoc.txt 改成 ./Vocabulary/ORBvoc.bin。解压后，将ORBvoc.bin拷贝到Vocabulary文件夹下。修改加载词袋的类型为 ：BinaryFile。
vins-mono(4)重定位以及全局优化
Hcaroline
11-13 818
vins的重定位模块主要包含回环检测,回环候选帧之间的特征匹配,紧耦合重定位三个部分. a.回环检测: 采用BRIEF描述子的DBOW2词袋进行闭环检测,对新来的关键帧重新检测500个角点进行闭环检测同时对所有角点进行BRIEF描述,然后计算当前帧与词袋的相似度,与关键帧数据库中所有帧进行对比,通过闭环一致性检测得到闭环候选帧.(回环检测只对关键帧进行,当一帧被加入到关键帧中时才进行回环检测) b...
DBoW2库介绍
weixin_30477293的博客
11-05 448
DBoW2库是University of Zaragoza里的Lopez等人开发的开源软件库。 由于在SLAM回环检测上的优异表现（特别是ORB-SLAM2），DBoW2库受到了广大SLAM爱好者的关注。本文希望通过深入解析DBoW2库及相关的DLoopDetector库，为读者后续使用这两个库提供参考。 git地址： DBoW2 DLoopDetector 论文：Bags of Binary W...
ORB-SLAM2添加稠密建图线程
zhou2677273778的博客
08-10 2846
ORB-SLAM2稠密点云建图
ORBSLAM2 Win10 VS2017 二进制词袋修改
滥觞
11-26 814
步骤前言词袋下载TemplatedVocabulary.h 文件修改System.cc 文件修改 前言   资料汇总，步骤记录，仅供参考。 词袋下载   前往 https://github.com/nxyzgf/sgg-dbow2 下载ORBvoc.bin TemplatedVocabulary.h 文件修改   首先在第240行左右，loadFromTextFile函数的声明下增加如下声明： /** * Loads the vocabulary from a text file * @pa
线切割优化：提升VO/VSLAM精确度的关键策略
本文主要探讨了在视觉定位(VO)和视觉 simultaneous localization and mapping (VSLAM) 中，如何有效地利用"良好的线切割"技术来提升姿态优化的精度。传统的VO/VSLAM方法通常依赖于点特征，但在低纹理和运动模糊等...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值