MeshIO.hpp

Go to the documentation of this file.

#pragma once
 
#ifndef LVR2_IO_HDF5_MESHIO_HPP
#define LVR2_IO_HDF5_MESHIO_HPP
 
#include <boost/optional.hpp>
 
#include "lvr2/io/MeshBuffer.hpp"
#include "lvr2/io/AttributeMeshIOBase.hpp"
#include <highfive/H5DataSet.hpp>
#include <highfive/H5DataSpace.hpp>
#include <highfive/H5File.hpp>
 
// Dependencies
#include "ChannelIO.hpp"
#include "VariantChannelIO.hpp"
#include "ArrayIO.hpp"
 
namespace lvr2 {
namespace hdf5features {
 
template<typename Derived>
class MeshIO : public AttributeMeshIOBase {
public:
    void save(std::string name, const MeshBufferPtr& buffer);
    void save(HighFive::Group& group, const MeshBufferPtr& buffer);
 
    MeshBufferPtr load(std::string name);
    MeshBufferPtr load(HighFive::Group& group);
    MeshBufferPtr loadMesh(std::string name);
 
    void setMeshName(std::string meshName);
 
protected:
 
    bool isMesh(HighFive::Group& group);
 
    Derived* m_file_access = static_cast<Derived*>(this);
 
    std::string m_mesh_name = "";
 
    // dependencies
    VariantChannelIO<Derived>* m_vchannel_io = static_cast<VariantChannelIO<Derived>*>(m_file_access);
 
    static constexpr const char* ID = "MeshIO";
    static constexpr const char* OBJID = "MeshBuffer";
 
    ArrayIO<Derived>* m_array_io = static_cast<ArrayIO<Derived>*>(m_file_access);
 
    FloatChannelOptional getVertices();
 
    IndexChannelOptional getIndices();
 
    bool addVertices(const FloatChannel& channel_ptr);
 
    bool addIndices(const IndexChannel& channel_ptr);
 
    template <typename T>
    bool getChannel(const std::string group, const std::string name, boost::optional<AttributeChannel<T>>& channel);
 
    virtual bool getChannel(const std::string group, const std::string name, FloatChannelOptional& channel);
 
    virtual bool getChannel(const std::string group, const std::string name, IndexChannelOptional& channel);
 
    virtual bool getChannel(const std::string group, const std::string name, UCharChannelOptional& channel);
 
    template <typename T>
    bool addChannel(const std::string group, const std::string name, const AttributeChannel<T>& channel);
 
    virtual bool addChannel(const std::string group, const std::string name, const FloatChannel& channel);
 
    virtual bool addChannel(const std::string group, const std::string name, const IndexChannel& channel);
 
    virtual bool addChannel(const std::string group, const std::string name, const UCharChannel& channel);
 
 
};
 
 
} // hdf5features
 
 
template<typename Derived>
struct Hdf5Construct<hdf5features::MeshIO, Derived> {
    
    // DEPS
    using dep1 = typename Hdf5Construct<hdf5features::VariantChannelIO, Derived>::type;
    using dep2 = typename Hdf5Construct<hdf5features::ArrayIO, Derived>::type;
    using deps = typename dep1::template Merge<dep2>;
 
    // ADD THE FEATURE ITSELF
    using type = typename deps::template add_features<hdf5features::MeshIO>::type;
     
};
 
} // namespace lvr2
 
#include "MeshIO.tcc"
 
#endif // LVR2_IO_HDF5_MESHIO_HPP