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