PlutoMapIO.hpp

Go to the documentation of this file.

 
#ifndef __LVR2_PLUTOMAPIO_HPP_
#define __LVR2_PLUTOMAPIO_HPP_
 
 
#include <string>
#include <vector>
#include <iostream>
#include <unordered_map>
 
#include <H5Tpublic.h>
#include <highfive/H5File.hpp>
 
#include "lvr2/geometry/BaseVector.hpp"
 
namespace hf = HighFive;
 
using std::string;
using std::vector;
using std::unordered_map;
 
namespace lvr2
{
 
using Vec = BaseVector<float>;
 
struct PlutoMapImage {
    string name;
    uint32_t width;
    uint32_t height;
    uint32_t channels;
    vector<uint8_t> data;
};
 
struct PlutoMapMaterial {
    int32_t textureIndex;
    uint8_t r;
    uint8_t g;
    uint8_t b;
};
 
class PlutoMapIO
{
public:
    PlutoMapIO(string filename);
 
    PlutoMapIO(
        string filename,
        const vector<float>& vertices,
        const vector<uint32_t>& face_ids
    );
 
    ~PlutoMapIO();
 
    vector<float> getVertices();
 
    vector<uint32_t> getFaceIds();
 
    vector<float> getVertexNormals();
 
    vector<uint8_t> getVertexColors();
 
    // TODO: replace PlutoMapImage with lvr2::Texture?
    vector<PlutoMapImage> getTextures();
 
    unordered_map<Vec, vector<float>> getFeatures();
 
    vector<PlutoMapMaterial> getMaterials();
 
    vector<uint32_t> getMaterialFaceIndices();
 
    vector<float> getVertexTextureCoords();
 
    vector<string> getLabelGroups();
 
    vector<string> getAllLabelsOfGroup(string groupName);
 
    vector<uint32_t> getFaceIdsOfLabel(string groupName, string labelName);
 
    vector<float> getRoughness();
 
    vector<float> getHeightDifference();
 
    PlutoMapImage getImage(hf::Group group, string name);
 
    hf::DataSet addVertexNormals(vector<float>& normals);
 
    hf::DataSet addVertexColors(vector<uint8_t>& colors);
 
    void addTexture(int index, uint32_t width, uint32_t height, uint8_t* data);
 
    void addMaterials(vector<PlutoMapMaterial>& materials, vector<uint32_t>& matFaceIndices);
 
    void addVertexTextureCoords(vector<float>& coords);
 
    void addLabel(string groupName, string labelName, vector<uint32_t>& faceIds);
 
    template<typename BaseVecT>
    void addTextureKeypointsMap(unordered_map<BaseVecT, std::vector<float>>& keypoints_map);
 
    void addRoughness(vector<float>& roughness);
 
    void addHeightDifference(vector<float>& diff);
 
    void addImage(hf::Group group,
                  string name,
                  const uint32_t width,
                  const uint32_t height,
                  const uint8_t* pixelBuffer
    );
 
    bool removeAllLabels();
 
    void flush();
 
private:
    hf::File m_file;
 
    // group names
 
    static constexpr const char* GEOMETRY_GROUP = "/geometry";
    static constexpr const char* ATTRIBUTES_GROUP = "/attributes";
    static constexpr const char* CLUSTERSETS_GROUP = "/clustersets";
    static constexpr const char* TEXTURES_GROUP = "/textures";
    static constexpr const char* LABELS_GROUP = "/labels";
 
    // main groups for reference
    hf::Group m_geometryGroup;
    hf::Group m_attributesGroup;
    hf::Group m_clusterSetsGroup;
    hf::Group m_texturesGroup;
    hf::Group m_labelsGroup;
};
} // namespace lvr2
 
 
namespace HighFive {
 
template <>
inline AtomicType<lvr2::PlutoMapMaterial>::AtomicType()
{
    hid_t materialHid = H5Tcreate(H5T_COMPOUND, sizeof(lvr2::PlutoMapMaterial));
 
    H5Tinsert(materialHid, "textureIndex", offsetof(lvr2::PlutoMapMaterial, textureIndex), H5T_NATIVE_INT);
    H5Tinsert(materialHid, "r", offsetof(lvr2::PlutoMapMaterial, r), H5T_NATIVE_UCHAR);
    H5Tinsert(materialHid, "g", offsetof(lvr2::PlutoMapMaterial, g), H5T_NATIVE_UCHAR);
    H5Tinsert(materialHid, "b", offsetof(lvr2::PlutoMapMaterial, b), H5T_NATIVE_UCHAR);
 
    _hid = H5Tcopy(materialHid);
}
 
}
 
#include "PlutoMapIO.tcc"
 
#endif // __LVR2_PLUTOMAPIO_HPP_