ChunkHashGrid.hpp

Go to the documentation of this file.

 
#ifndef CHUNK_HASH_GRID_HPP
#define CHUNK_HASH_GRID_HPP
 
#include "lvr2/io/MeshBuffer.hpp"
#include "lvr2/io/PointBuffer.hpp"
#include "lvr2/io/hdf5/HDF5FeatureBase.hpp"
#include "lvr2/io/hdf5/ChunkIO.hpp"
 
#include <list>
#include <unordered_map>
 
namespace lvr2
{
 
class ChunkGeomtryChannelVisitor : public boost::static_visitor<FloatChannelOptional>
{
  public:
    FloatChannelOptional operator()(const MeshBufferPtr mesh) const
    {
        return mesh->getFloatChannel("vertices");
    }
 
    FloatChannelOptional operator()(const PointBufferPtr points) const
    {
        return points->getFloatChannel("points");
    }
};
 
class ChunkHashGrid
{
  public:
    using val_type = boost::variant<MeshBufferPtr, PointBufferPtr>;
 
    using io = Hdf5Build<hdf5features::ChunkIO>;
 
    explicit ChunkHashGrid(std::string hdf5Path, size_t cacheSize, float chunkSize = 10.0f);
 
    ChunkHashGrid(std::string hdf5Path,
                  size_t cacheSize,
                  BoundingBox<BaseVector<float>> boundingBox,
                  float chunkSize);
 
    template <typename T>
    void setGeometryChunk(std::string layer, int x, int y, int z, T data);
 
    template <typename T>
    void setChunk(std::string layer, int x, int y, int z, T data);
 
    template <typename T>
    boost::optional<T> getChunk(std::string layer, int x, int y, int z);
 
    bool isChunkLoaded(std::string layer, size_t hashValue);
 
    bool isChunkLoaded(std::string layer, int x, int y, int z);
 
    inline std::size_t hashValue(int i, int j, int k) const
    {
        return (i + m_chunkIndexOffset.x) * m_chunkAmount.y * m_chunkAmount.z
               + (j + m_chunkIndexOffset.y) * m_chunkAmount.z + k + m_chunkIndexOffset.z;
    }
 
    const BoundingBox<BaseVector<float>>& getBoundingBox() const
    {
        return m_boundingBox;
    }
 
    float getChunkSize() const
    {
        return m_chunkSize;
    }
 
    const BaseVector<std::size_t>& getChunkAmount() const
    {
        return m_chunkAmount;
    }
 
    BaseVector<int> getChunkMinChunkIndex() const
    {
        BaseVector<int> offset(m_chunkIndexOffset.x, m_chunkIndexOffset.y, m_chunkIndexOffset.z);
        return offset * -1;
    }
 
    BaseVector<int> getChunkMaxChunkIndex() const
    {
        BaseVector<int> maxChunkIndex(m_chunkAmount.x - m_chunkIndexOffset.x,
                                      m_chunkAmount.y - m_chunkIndexOffset.y,
                                      m_chunkAmount.z - m_chunkIndexOffset.z);
        return maxChunkIndex;
    }
 
    void setBoundingBox(const BoundingBox<BaseVector<float>> boundingBox);
 
  protected:
    void rehashCache(const BaseVector<std::size_t>& oldChunkAmount,
                     const BaseVector<std::size_t>& oldChunkIndexOffset);
 
    void expandBoundingBox(const val_type& data);
 
    template <typename T>
    bool loadChunk(std::string layer, int x, int y, int z);
 
    void loadChunk(std::string layer, int x, int y, int z, const val_type& data);
 
    void setChunkSize(float chunkSize)
    {
        m_chunkSize = chunkSize;
        m_io.saveChunkSize(m_chunkSize);
    }
 
    // bounding box of the entire chunked model
    // i had to make this protected because of the getGlobalBoundingBox() function in ChunkManager
    BoundingBox<BaseVector<float>> m_boundingBox;
 
  private:
    void setChunkAmountAndOffset(const BaseVector<std::size_t>& chunkAmount,
                                 const BaseVector<std::size_t>& chunkIndexOffset);
 
  private:
    // chunkIO for the HDF5 file-IO
    io m_io;
 
    // number of chunks that will be cached before deleting old chunks
    size_t m_cacheSize;
 
    // ordered list to save recently used hashValues for the lru cache
    std::list<std::pair<std::string, size_t>> m_items;
 
    // hash map containing chunked meshes
    std::unordered_map<std::string, std::unordered_map<size_t, val_type>> m_hashGrid;
 
    // size of chunks
    float m_chunkSize;
 
    // amount of chunks
    BaseVector<std::size_t> m_chunkAmount;
 
    // offset of chunks to make chunk index start at 0
    BaseVector<std::size_t> m_chunkIndexOffset;
};
 
} /* namespace lvr2 */
 
#include "ChunkHashGrid.tcc"
 
#endif // CHUNK_HASH_GRID_HPP