PlyFile.h

Go to the documentation of this file.

#pragma once
 
#include "DataIO/FileSystem/Path.h"
#include "Utility/SemanticVersion.h"
#include "Math/constant.h"
 
#include <Common/primitive_type.h>
 
#include <vector>
#include <cstddef>
#include <string>
#include <string_view>
#include <climits>
 
namespace ph { class IInputStream; }
 
namespace ph
{
 
enum class EPlyDataFormat
{
    ASCII = 0,
    BinaryLittleEndian,
    BinaryBigEndian,
 
    NUM
};
 
enum class EPlyDataType
{
    Unspecified = 0,
 
    Int8,
 
    UInt8,
 
    Int16,
 
    UInt16,
 
    Int32,
 
    UInt32,
 
    Float32,
 
    Float64,
 
    NUM
};
 
struct PlyIOConfig final
{
    bool bIgnoreComments = true;
 
    bool bPreloadIntoMemory = true;
 
    std::size_t preloadMemoryThreshold = 1 * math::constant::GiB;
 
    std::size_t reduceStorageMemoryThreshold = 768 * math::constant::MiB;
};
 
class PlyPropertyValues;
class PlyPropertyListValues;
 
struct PlyProperty final
{
    std::string  name;
    EPlyDataType dataType;
    EPlyDataType listSizeType;
    std::size_t  strideOffset;
    std::size_t  fixedListSize;
 
    std::vector<std::byte> rawListBuffer;
 
    std::vector<std::size_t> listSizesPrefixSum;
 
    PlyProperty();
 
    bool isList() const;
    bool isFixedSizeList() const;
};
 
struct PlyElement final
{
    std::string              name;
    std::size_t              numElements;
    std::vector<PlyProperty> properties;
    std::size_t              strideSize;
 
    std::vector<std::byte> rawBuffer;
 
    PlyElement();
 
    bool isLoaded() const;
    bool containsList() const;
    PlyProperty* findProperty(std::string_view name);
    PlyPropertyValues propertyValues(PlyProperty* prop);
    PlyPropertyListValues listPropertyValues(PlyProperty* prop);
};
 
class PlyPropertyValues final
{
    friend PlyElement;
 
public:
    float64 get(std::size_t index) const;
    void set(std::size_t index, float64 value);
    std::size_t size() const;
    operator bool () const;
 
private:
    PlyPropertyValues();
 
    PlyPropertyValues(
        std::byte*   rawBuffer,
        std::size_t  strideSize,
        std::size_t  numElements,
        EPlyDataType valueType);
 
    std::size_t getBufferOffset(std::size_t index) const;
 
    std::byte*   m_rawBuffer;
    std::size_t  m_strideSize;
    std::size_t  m_numElements;
    EPlyDataType m_valueType;
};
 
class PlyPropertyListValues final
{
    friend PlyElement;
 
public:
    float64 get(std::size_t listIndex, std::size_t listElementIndex) const;
    void set(std::size_t listIndex, std::size_t listElementIndex, float64 value);
    
    std::size_t size() const;
 
    std::size_t listSize(std::size_t listIndex) const;
 
    bool isFixedSizeList() const;
    std::size_t fixedListSize() const;
    operator bool () const;
 
private:
    PlyPropertyListValues();
 
    PlyPropertyListValues(
        std::byte*   rawBuffer,
        std::size_t* listSizesPrefixSum,
        std::size_t  numLists,
        std::size_t  fixedListSize,
        EPlyDataType valueType);
 
    std::size_t getBufferOffset(std::size_t listIndex, std::size_t listElementIndex) const;
 
    std::byte*   m_rawBuffer;
    std::size_t* m_listSizesPrefixSum;
    std::size_t  m_numLists;
    std::size_t  m_fixedListSize;
    EPlyDataType m_valueType;
};
 
class PlyFile final
{
    static_assert(sizeof(std::byte) * CHAR_BIT == 8,
        "The file explicitly depends on the fact that std::byte contains 8 bits.");
 
public:
    PlyFile();
 
    explicit PlyFile(const Path& plyFilePath);
 
    PlyFile(const Path& plyFilePath, const PlyIOConfig& config);
 
    PlyElement* findElement(std::string_view name);
    std::size_t numElements() const;
 
    EPlyDataFormat getInputFormat() const;
    void setInputFormat(EPlyDataFormat format);
    EPlyDataFormat getOutputFormat() const;
    void setOutputFormat(EPlyDataFormat format);
 
    std::size_t numComments() const;
    std::string_view getComment(std::size_t commentIndex) const;
 
    void loadFile(const Path& plyFilePath, const PlyIOConfig& config);
 
    void clearBuffer();
 
    SemanticVersion getVersion() const;
 
private:
    void parseHeader(IInputStream& stream, const PlyIOConfig& config);
 
    void loadBuffer(IInputStream& stream, const PlyIOConfig& config);
 
    void loadAsciiElementBuffer(
        IInputStream& stream, 
        PlyElement& element, 
        const PlyIOConfig& config);
 
    void loadBinaryElementBuffer(
        IInputStream& stream, 
        PlyElement& element, 
        const PlyIOConfig& config);
 
    void loadNonListBinaryElementBuffer(
        IInputStream& stream,
        PlyElement& element,
        const PlyIOConfig& config);
 
    void loadSingleBinaryPlyDataToBuffer(
        IInputStream& stream, 
        EPlyDataType dataType, 
        std::byte* out_buffer);
 
    void compactBuffer();
 
    void reserveBuffer();
 
private:
    EPlyDataFormat           m_inputFormat;
    EPlyDataFormat           m_outputFormat;
    EPlyDataFormat           m_nativeFormat;
    SemanticVersion          m_version;
    std::vector<std::string> m_comments;
    std::vector<PlyElement>  m_elements;
};
 
}// end namespace ph