hdf5_map_io.h

Go to the documentation of this file.

#ifndef HDF5_MAP_IO__H_
#define HDF5_MAP_IO__H_
 
#include <string>
#include <vector>
#include <iostream>
#include <unordered_map>
 
#include <H5Tpublic.h>
#include <highfive/H5File.hpp>
 
namespace hf = HighFive;
 
namespace hdf5_map_io
{
 
struct MapVertex {
    float x;
    float y;
    float z;
};
 
 
struct MapImage {
    std::string name;
    uint32_t width;
    uint32_t height;
    uint32_t channels;
    std::vector<uint8_t> data;
};
 
struct MapMaterial {
    int32_t textureIndex;
    uint8_t r;
    uint8_t g;
    uint8_t b;
};
 
class HDF5MapIO
{
public:
    HDF5MapIO(std::string filename);
 
    HDF5MapIO(
        std::string filename,
        const std::vector<float>& vertices,
        const std::vector<uint32_t>& face_ids
    );
 
    ~HDF5MapIO();
 
    std::vector<float> getVertices();
 
    std::vector<uint32_t> getFaceIds();
 
    std::vector<float> getVertexNormals();
 
    std::vector<uint8_t> getVertexColors();
 
    std::vector<MapImage> getTextures();
 
    std::unordered_map<MapVertex, std::vector<float>> getFeatures();
 
    std::vector<MapMaterial> getMaterials();
 
    std::vector<uint32_t> getMaterialFaceIndices();
 
    std::vector<float> getVertexTextureCoords();
 
    std::vector<std::string> getLabelGroups();
 
    std::vector<std::string> getAllLabelsOfGroup(std::string groupName);
 
    std::vector<uint32_t> getFaceIdsOfLabel(std::string groupName, std::string labelName);
 
    std::vector<float> getRoughness();
 
    std::vector<float> getHeightDifference();
 
    std::vector<float> getVertexCosts(std::string costlayer);
 
    std::vector<std::string> getCostLayers();
 
    MapImage getImage(hf::Group group, std::string name);
 
    hf::DataSet addVertexNormals(std::vector<float>& normals);
 
    hf::DataSet addVertexColors(std::vector<uint8_t>& colors);
 
    void addTexture(int index, uint32_t width, uint32_t height, uint8_t* data);
 
    void addMaterials(std::vector<MapMaterial>& materials, std::vector<uint32_t>& matFaceIndices);
 
    void addVertexTextureCoords(std::vector<float>& coords);
 
    void addLabel(std::string groupName, std::string labelName, std::vector<uint32_t>& faceIds);
 
    void addOrUpdateLabel(std::string groupName, std::string labelName, std::vector<uint32_t>& faceIds);
 
    void addTextureKeypointsMap(std::unordered_map<MapVertex, std::vector<float>>& keypoints_map);
 
    void addRoughness(std::vector<float>& roughness);
 
    void addHeightDifference(std::vector<float>& diff);
 
    void addImage(hf::Group group,
                  std::string name,
                  const uint32_t width,
                  const uint32_t height,
                  const uint8_t* pixelBuffer
    );
 
    bool removeAllLabels();
 
    void flush();
 
private:
    hf::File m_file;
 
    void creatOrGetGroups();
 
    size_t getSize(hf::DataSet& data_set);
    // group names
    static constexpr const char* CHANNELS_GROUP = "/mesh/channels";
    static constexpr const char* CLUSTERSETS_GROUP = "/mesh/clustersets";
    static constexpr const char* TEXTURES_GROUP = "/mesh/textures";
    static constexpr const char* LABELS_GROUP = "/mesh/labels";
 
    // main groups for reference
    hf::Group m_channelsGroup;
    hf::Group m_clusterSetsGroup;
    hf::Group m_texturesGroup;
    hf::Group m_labelsGroup;
};
} // namespace hdf5_map_io
 
 
namespace HighFive {
 
template <>
inline AtomicType<hdf5_map_io::MapMaterial>::AtomicType()
{
    hid_t materialHid = H5Tcreate(H5T_COMPOUND, sizeof(hdf5_map_io::MapMaterial));
 
    H5Tinsert(materialHid, "textureIndex", offsetof(hdf5_map_io::MapMaterial, textureIndex), H5T_NATIVE_INT);
    H5Tinsert(materialHid, "r", offsetof(hdf5_map_io::MapMaterial, r), H5T_NATIVE_UCHAR);
    H5Tinsert(materialHid, "g", offsetof(hdf5_map_io::MapMaterial, g), H5T_NATIVE_UCHAR);
    H5Tinsert(materialHid, "b", offsetof(hdf5_map_io::MapMaterial, b), H5T_NATIVE_UCHAR);
 
    _hid = H5Tcopy(materialHid);
}
 
}
 
namespace std
{
template <>
struct hash<hdf5_map_io::MapVertex>
{
  size_t operator()(const hdf5_map_io::MapVertex& k) const
  {
      size_t h1 = std::hash<double>()(k.x);
      size_t h2 = std::hash<double>()(k.y);
      size_t h3 = std::hash<double>()(k.z);
      return (h1 ^ (h2 << 1)) ^ h3;
  }
};
 
template <>
struct equal_to<hdf5_map_io::MapVertex>
{
  bool operator()( const hdf5_map_io::MapVertex& lhs, const hdf5_map_io::MapVertex& rhs ) const{
      return (lhs.x == rhs.x) && (lhs.y == rhs.y) && (lhs.z == rhs.z);
  }
};
 
}
 
#endif // HDF5_MAP_IO__H_