DBoW2算法

DBoW2是一种高效的回环检测算法，DBow2算法的全称为Bags of binary words for fast place recognition in image sequence,使用的特征检测算法为Fast，描述子为BRIEF描述子，是一种离线方法。

算法流程
Bag of Words字典建立方法（最终得到的就是每一层的不同类的median，每一个叶子节点对应的就是一个词汇）

建树流程

权重设置
权重设置用的是idf，意思是词汇在训练过程中出现的频率越高，区分度越低，因此权重越低
$\ \ \ \ \ \ idf = log\frac{N}{n_i}$

每一个节点包含

struct Node
{
    //在所有节点中的标号
    NodeId id;

    //该节点的权重，该权重为
    //训练的过程中设置的，在得到了树之后，
    //所有的描述子过一遍树，得到每一个单词出现
    //的次数，除以总的描述子数目
    WorldValue weight；

    //描述符，为每一类的均值（对于brief描述子，则要对均值进行二值化）
    TDescriptor descriptor;

    //如果有叶节点，则有词汇的ID
    WordID word_id;
}

上面的方法是分层聚类的，每一次聚类得到的多个节点，都有median v表示该类，可以用来判断新的词汇是否属于该类。最终建立的树包括W个叶节点，也就是W个视觉词汇，词汇也用median表示。

http://www.cnblogs.com/jian-li/p/5664559.html

---

视觉词典
DBoW2库采用树状结构存储词袋，搜索复杂度在log（N)。每个叶节点被赋予一个权重，默认为TF-IDF。

TF-IDF主要思想是:如果某个词或短语在一片文章中出现的频率TF高,并且在其他文章中很少出现,则认为此词或者短语具有很好的类别区分能力,适合用来分类.TF-IDF实际上是TF*IDF,TF代表词频(Term Frequency),表示词条在文档d中的出现频率.IDF代表逆向文件频率(Inverse Document Frequency)。如果包含词条t的文档越少，IDF越大，表明词条t具有很好的类别区分能力。
第k个叶节点的TF和IDF分别定义为

$$IDF_k = log\frac{number\ of\ all\ images}{number\ of\ images\ reach\ k-th\ leaf\ node}$$
$$TF_k = log\frac{number\ of\ features\ locates\ in\ leaf\ node\ k}{number\ of\ all\ features}$$
视觉词典可以通过离线训练大量数据得到。训练中只计算和保存单词的IDF值，即单词在众多图像中的区分度。TF则是从实际图像中计算得到各个单词的频率。单词的TF越高，说明单词在这幅图像中出现的越多；单词的IDF越高，说明单词本身具有高区分度。二者结合起来，即可得到这幅图像的BoW描述。

template<class TDescriptor, class F>
void TemplatedVocabulary<TDescriptor, F>::create(
  const std::vector<std::vector<TDescriptor> > &training_features, // 图像特征集合
  int k, // 每层的类的个数
  int L, // 树的层数
  WeightingType weighting, //权重类型，默认为TF-IDF
  ScoringType scoring) // 得分的类型，默认为L1-norm
  {
      m_nodes.clear();
      m_words.clear();

      //节点数 = Sum_(i=0..L) (k^i)
      int expected_nodes = (int)((pow((double)m_k,(double)m_L + 1) - 1) / (m_k - 1));
      m_nodes.reserve(expected_nodes);

      //将所有特征描述集合到一个vector
      std::vector<pDescriptor> features;
      getFeature(training_features, features);

      //生成根节点
      m_nodes.push_back(Node(0)); //root

      //k-means++ (内有递归)
      HKmeansStep(0, features, 1);

      //建立一个只有叶节点的序列m_words
      createWords();

      //为每一个叶节点生成权重，此处计算IDF部分，如果不用IDF，则为1
      setNodeWeights(training_features)
  }

  /*k-means++过程*/

  template<class TDescriptor, class F>
  void TemplatedVocabulary<TDescriptor, F>::HKmeansStep(
    NodeId parent_id, // 父节点ID
    const std::vector<pDescriptor> &descriptor, // 该父节点对应的描述集合
    int current_level // 当前层数)
    {
        if(descriptors.empty()) return;

        //用来储存子节点的特征描述
        std::vector<TDescriptor> clusters;

        //用来储存每一个子节点对应的特征描述在descriptor向量中的id
        std::vector<std::vector<unsigned int > groups; //groups[i] = {j1, j2, ...}
        // j1, j2 ... indices of descriptors associated to cluster 1

        clusters.reserve(m_k);
        group.reserve(m_k);

        //如果特征描述个数小于m_k，直接分类
        if((int)descriptors.size() <= m_k)
        {
            groups.resize(descriptors.size());

            for(unsigned int i = 0; i < descriptors.size(); i++)
            {
                groups[i].push_back(i);
                clusters[i].push_back(*descriptors[i]);
            }
        }
        else
        {
            //k_means分类
            bool first_time = true;
            bool goon = true;

            //用来检测迭代过程中前后两次分类结果是否一致，如果一致，分类结束
            std::vector<int> last_association, current_association;

            //迭代过程
            while(goon)
            {
                // 1. 分类
                if(first_time)
                {
                    //第一次分类，初始化分类
                    initiateClusters(descriptors, clusters);
                }
                else
                {
                    //计算每一类的meanValue
                    for(unsigned int c = 0; c < clusters.size(); c++)
                    {
                        std::vector<pDescriptor> cluster_descriptors;
                        cluster_descriptors.reserve(groups[c].size());

                        //利用group,读取每一类对应的id
                        std::vector<unsigned int>::const_iterator vit;

                        for(vit = groups[c].begin(); vit != groups[c].end(); ++vit)
                        {
                            cluster_descriptors.push_back(descriptors[*vit]);
                        }

                        //计算meanValue
                        F::meanValue(cluster_descriptors, clusters[c]);
                    }
                }

                // 2. 利用1计算的中心重新分类
                groups.clear();
                groups.resize(clusters.size(), std::vector<unsigned int>());
                current_association.resize(descriptors.size());

                typename std::vector<pDescriptor>::const_iterator fit;

                //对每一个特征，计算它与k个中心特征的距离，标记距离最小的中心特征的id
                for(fit = descriptors.begin(); fit != descriptors.end(); ++fit)
                {
                    double best_dist = F::distance(*(*fit)), clusters[0]);
                    undigned int icluster = 0;
                    for(unsigned int c = 1; c < clusters.size(); ++c)
                    {
                        double dist = F::distance(*(*fit), clusters[c]);
                        if(dist < best_dist)
                        {
                            best_dist = dist;
                            icluster = c;
                        }
                    }
                    //记录分类信息
                    groups[icluster].push_back(fit - descriptors.begin());
                    current_association[fit - descriptors.begin()] = icluster;
                }

                //k-means++ ensures all the clusters has any feature associated with them
                //3 . 检测前后两次分类结果是否一致，如一致，分类结束
                if(first_time)
                    first_time = false;
                else
                {
                    goon = false;
                    for(unsigned int i = 0; i < current_association.size(); i++)
                    {
                        if(current_association[i] != last_association[i])
                            goon = true;
                        break;
                    }
                }

                if(goon)
                {
                    last_association = current_association;
                }
            }

            //生成本层的节点，其特征描述为每一类的meanValue
            for(unsigned int i = 0; i < clusters.size(); ++i)
            {
                NodeId id = m_nodes.size();
                m_nodes.push_back(Node(id));
                m_nodes.back().descriptor = clusters[i];
                m_nodes.back().parent = parent_id;
                m_nodes[parent_id].children.push_back(id);
            }

            // go on with the next level
            if(current_level < m_L)
            {
                // iterate again with the resulting clusters
                const std::vector<NodeId> &children_ids = m_nodes[parent_id].children;
                for(unsigned int i = 0; i < clusters.size(); ++i)
                {
                    NodeId id = children_ids[i];

                    std::vector<pDescriptor> child_features;
                    child_features.reserve(groups[i].size());

                    std::vector<unsigned int>::const_iterator vit;
                    for(vit = groups[i].begin(); vit != groups[i].end(); ++vit)
                    {
                        child_features.push_back(descriptors[*vit]);
                    }

                    //进入下一层，继续分类
                    if(child_features.size() > 1)
                    {
                        HKmeansStep(id, child_features, current_level + 1);
                    }
                }
            }
    }