HDF5IO.hpp

Go to the documentation of this file.

#ifndef HDF5IO_HPP_
#define HDF5IO_HPP_

#include "BaseIO.hpp"
#include "DataStruct.hpp"

#include "lvr2/geometry/BaseVector.hpp"
#include "lvr2/io/AttributeMeshIOBase.hpp"
// #include "lvr2/types/Hyperspectral.hpp"
#include "lvr2/types/MatrixTypes.hpp"
#include "lvr2/types/ScanTypes.hpp"

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>

#include <H5Tpublic.h>
#include <hdf5_hl.h>
#include <highfive/H5DataSet.hpp>
#include <highfive/H5DataSpace.hpp>
#include <highfive/H5File.hpp>


#include <string>

namespace lvr2
{

class HDF5IO : public BaseIO, public AttributeMeshIOBase
{
  public:

    static const std::string vertices_name;
    static const std::string indices_name;
    static const std::string meshes_group;

    virtual ModelPtr read(std::string filename);

    ModelPtr read(std::string filename, size_t scanNr);

    bool readPointCloud(ModelPtr model_ptr);

    bool readMesh(ModelPtr model_ptr);


    virtual void save(std::string filename);

    virtual void save(ModelPtr model, std::string filename);

    bool saveMesh(ModelPtr model_ptr);



    HDF5IO() {}

    HDF5IO(std::string filename, int open_flags = HighFive::File::ReadWrite);

    HDF5IO(const std::string filename, const std::string part_name, int open_flags = HighFive::File::ReadOnly);

    virtual ~HDF5IO();

    bool open(std::string filename, int open_flag);

    Texture getImage(std::string groupName, std::string datasetName);

    ScanPtr getSingleRawScan(int nr, bool load_points = true);

    ScanImage getSingleRawCamData(int scan_id, int img_id, bool load_image_data = true);

    std::vector<ScanPtr> getRawScans(bool load_points = true);

    std::vector<std::vector<ScanImage> > getRawCamData(bool load_image_data = true);

    floatArr getFloatChannelFromRawScan(std::string name,
            int nr, unsigned int& n, unsigned& w);

   

    void addImage(
            std::string groupName, std::string name, cv::Mat& img);
    
    void addRawScan(int nr, ScanPtr scan);

    void addRawCamData( int scan_id, int img_id, ScanImage& cam_data );

    void addFloatChannelToRawScan(std::string name, int nr, size_t n, unsigned w, floatArr data);

    void addRawDataHeader(std::string description, Matrix4<BaseVector<float>> &referenceFrame);

//     void addHyperspectralCalibration(int position, const HyperspectralPanorama& hyperspectral);

    void setCompress(bool compress);
    void setChunkSize(const size_t& size);
    void setPreviewReductionFactor(const unsigned int factor);
    void setUsePreviews(bool use);

    bool compress();

    bool deleteDataset(const char* name);

    size_t chunkSize();

    template<typename T>
    boost::shared_array<T> getArray(
            std::string groupName, std::string datasetName,
            unsigned int& size);

    template<typename T>
    boost::shared_array<T> getArray(
            std::string groupName, std::string datasetName,
            std::vector<size_t>& dim);

    template<typename T>
    void addArray(
            std::string groupName,
            std::string datasetName,
            unsigned int size,
            boost::shared_array<T> data);

    template<typename T>
    void addArray(
            std::string groupName,
            std::string datasetName,
            std::vector<size_t>& dimensions,
            boost::shared_array<T> data);

    template<typename T>
    void addArray(
            std::string groupName,
            std::string datasetName,
            std::vector<size_t>& dimensions,
            std::vector<hsize_t>& chunkSize,
            boost::shared_array<T> data);

  private:

    virtual FloatChannelOptional getVertices();

    virtual IndexChannelOptional getIndices();

    virtual bool addVertices(const FloatChannel& channel_ptr);

    virtual 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);

    boost::optional<HighFive::Group> getMeshGroup(bool create = false);

    template<typename T>
    boost::shared_array<T> getArray(HighFive::Group& g, std::string datasetName, std::vector<size_t>& dim);

    Texture getImage(HighFive::Group& g, std::string datasetName);

    template<typename T>
    void addArray(HighFive::Group& g,
            std::string datasetName,
            std::vector<size_t>& dim,
            std::vector<hsize_t>& chunkSize,
            boost::shared_array<T>& data);

    void addImage(HighFive::Group& g, std::string datasetName, cv::Mat& img);

    void getImage(HighFive::Group& g, std::string datasetName, cv::Mat& img);

   

    std::vector<std::string> splitGroupNames(const std::string &groupName);

    bool exist(const std::string &groupName);

    void write_base_structure();

    bool isGroup(HighFive::Group grp, std::string objName);


    HighFive::Group getGroup(const std::string& groupName, bool create = true);

    HighFive::Group getGroup(HighFive::Group& g, const std::string& groupName, bool create = true);

    template <typename T>
    boost::shared_array<T> reduceData(boost::shared_array<T> data,
            size_t dataCount,
            size_t dataWidth,
            unsigned int reductionFactor,
            size_t *reducedDataCount);

    HighFive::File*         m_hdf5_file;

    bool                    m_compress;
    size_t                  m_chunkSize;
    bool                    m_usePreviews;
    unsigned int            m_previewReductionFactor;
    std::string             m_part_name;
    std::string             m_mesh_path;
};

} // namespace lvr2

#include "HDF5IO.tcc"

#endif /* !HDF5IO_HPP_ */