ChunkManager.hpp

Go to the documentation of this file.

#ifndef CHUNK_MANAGER_HPP
#define CHUNK_MANAGER_HPP

#include "lvr2/algorithm/ChunkBuilder.hpp"
#include "lvr2/algorithm/ChunkHashGrid.hpp"
#include "lvr2/geometry/BaseVector.hpp"
#include "lvr2/geometry/BoundingBox.hpp"
#include "lvr2/io/Model.hpp"
#include "lvr2/types/Channel.hpp"

namespace lvr2
{

class ChunkManager : public ChunkHashGrid
{
  public:
    using FilterFunction = std::function<bool(MultiChannelMap::val_type, size_t)>;

    ChunkManager(MeshBufferPtr meshes,
                 float chunksize,
                 float maxChunkOverlap,
                 std::string savePath,
                 std::string layer = std::string("mesh"),
                 size_t cacheSize = 200
                 );


    ChunkManager(std::vector<MeshBufferPtr> meshes,
                 float chunksize,
                 float maxChunkOverlap,
                 std::string savePath,
                 std::vector<std::string> layers,
                 size_t cacheSize = 200);

    ChunkManager(std::string hdf5Path, size_t cacheSize = 200, float chunkSize = 10.0f);

    inline BoundingBox<BaseVector<float>> getGlobalBoundingBox()
    {
        return m_boundingBox;
    }

    void buildChunks(MeshBufferPtr mesh, float maxChunkOverlap, std::string savePath, std::string layer = std::string("mesh"));

    MeshBufferPtr extractArea(const BoundingBox<BaseVector<float>>& area, std::string layer= std::string("mesh"));

    void extractArea(const BoundingBox<BaseVector<float> >& area,
                    std::unordered_map<std::size_t, MeshBufferPtr>& chunks,
                    std::string layer = std::string("mesh"));
                    

    MeshBufferPtr extractArea(const BoundingBox<BaseVector<float>>& area,
                              const std::map<std::string, FilterFunction> filter,
                              std::string layer = std::string("mesh"));

    std::vector<std::string> getChannelsFromMesh(std::string layer = std::string("mesh"));

    void loadAllChunks(std::string layer = std::string("mesh"));

  private:
    void initBoundingBox(MeshBufferPtr mesh);

    void
    cutLargeFaces(std::shared_ptr<HalfEdgeMesh<BaseVector<float>>> halfEdgeMesh,
                  float overlapRatio,
                  std::shared_ptr<std::unordered_map<unsigned int, unsigned int>> splitVertices,
                  std::shared_ptr<std::unordered_map<unsigned int, unsigned int>> splitFaces);

    BaseVector<float> getFaceCenter(std::shared_ptr<HalfEdgeMesh<BaseVector<float>>> mesh,
                                    const FaceHandle& handle) const;

    //    /**
    //     * @brief find corresponding grid cell of given point
    //     *
    //     * @param vec point of mesh to find cell id for
    //     * @return cell id
    //     */
    //    std::string getCellName(const BaseVector<float>& vec) const;

    BaseVector<int> getCellCoordinates(const BaseVector<float>& vec) const;
    
    template <typename T>
    ChannelPtr<T> extractChannelOfArea(
        std::unordered_map<std::size_t, MeshBufferPtr>& chunks,
        std::string channelName,
        std::size_t staticVertexIndexOffset,
        std::size_t numVertices,
        std::size_t numFaces,
        std::vector<std::unordered_map<std::size_t, std::size_t>>& areaVertexIndices);

    template <typename T>
    MultiChannelMap::val_type
    applyChannelFilter(const std::vector<bool>& vertexFilter,
                       const std::vector<bool>& faceFilter,
                       const size_t numVertices,
                       const size_t numFaces,
                       const MeshBufferPtr meshBuffer,
                       const MultiChannelMap::val_type& originalChannel) const;
};

} /* namespace lvr2 */

#include "ChunkManager.tcc"

#endif // CHUNK_MANAGER_HPP