Database.hpp

// This file is part of the AliceVision project.
// Copyright (c) 2016 AliceVision contributors.
// This Source Code Form is subject to the terms of the Mozilla Public License,
// v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at https://mozilla.org/MPL/2.0/.
 
#pragma once
 
#include "VocabularyTree.hpp"
#include <aliceVision/types.hpp>
 
#include <map>
#include <cstddef>
#include <string>
 
namespace aliceVision {
namespace voctree {
 
struct DocMatch
{
    DocId id{UndefinedIndexT};
    float score{0.0f};
 
    DocMatch() = default;
    DocMatch(DocId _id, float _score)
      : id(_id),
        score(_score)
    {}
 
    bool operator<(const DocMatch& other) const { return score < other.score; }
 
    bool operator==(const DocMatch& other) const { return id == other.id && score == other.score; }
    bool operator!=(const DocMatch& other) const { return !(*this == other); }
};
 
typedef std::vector<DocMatch> DocMatches;
 
std::ostream& operator<<(std::ostream& os, const DocMatches& matches);
 
class Database
{
  public:
    explicit Database(uint32_t num_words = 0);
 
    DocId insert(DocId doc_id, const SparseHistogram& document);
 
    void sanityCheck(std::size_t N, std::map<std::size_t, DocMatches>& matches) const;
 
    void find(const std::vector<Word>& document,
              std::size_t N,
              std::vector<DocMatch>& matches,
              const std::string& distanceMethod = "strongCommonPoints") const;
 
    void find(const SparseHistogram& query,
              std::size_t N,
              std::vector<DocMatch>& matches,
              const std::string& distanceMethod = "strongCommonPoints") const;
 
    void computeTfIdfWeights(float default_weight = 1.0f);
 
    std::size_t size() const;
 
    void saveWeights(const std::string& file) const;
    void loadWeights(const std::string& file);
 
    // Save weights and documents
    // void save(const std::string& file) const;
    // void load(const std::string& file);
 
    const SparseHistogramPerImage& getSparseHistogramPerImage() const { return database_; }
 
  private:
    struct WordFrequency
    {
        DocId id;
        uint32_t count;
 
        WordFrequency() = default;
        WordFrequency(DocId _id, uint32_t _count)
          : id(_id),
            count(_count)
        {}
    };
 
    // Stored in increasing order by DocId
    typedef std::vector<WordFrequency> InvertedFile;
 
    // typedef std::vector< std::pair<Word, float> > DocumentVector;
 
    friend std::ostream& operator<<(std::ostream& os, const SparseHistogram& dv);
 
    std::vector<InvertedFile> word_files_;
    std::vector<float> word_weights_;
    SparseHistogramPerImage database_;  // Precomputed for inserted documents
 
    void normalize(SparseHistogram& v) const;
};
 
}  // namespace voctree
}  // namespace aliceVision