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_ */