EBGeometry_Parser.hpp

Go to the documentation of this file.

/* EBGeometry
 * Copyright © 2022 Robert Marskar
 * Please refer to Copyright.txt and LICENSE in the EBGeometry root directory.
 */
 
#ifndef EBGeometry_Parser
#define EBGeometry_Parser
 
// Std includes
#include <vector>
#include <memory>
#include <map>
 
// Our includes
#include "EBGeometry_DCEL_Mesh.hpp"
#include "EBGeometry_MeshDistanceFunctions.hpp"
#include "EBGeometry_BoundingVolumes.hpp"
#include "EBGeometry_NamespaceHeader.hpp"
 
namespace Parser {
 
  enum class Encoding
  {
    ASCII,
    Binary,
    Unknown
  };
 
  enum class FileType
  {
    STL,
    PLY,
    Unsupported
  };
 
  template <typename T, typename Meta = DCEL::DefaultMetaData>
  inline static std::shared_ptr<EBGeometry::DCEL::MeshT<T, Meta>>
  readIntoDCEL(const std::string a_filename) noexcept;
 
  template <typename T, typename Meta = DCEL::DefaultMetaData>
  inline static std::vector<std::shared_ptr<EBGeometry::DCEL::MeshT<T, Meta>>>
  readIntoDCEL(const std::vector<std::string> a_files) noexcept;
 
  template <typename T, typename Meta = DCEL::DefaultMetaData>
  inline static std::shared_ptr<MeshSDF<T, Meta>>
  readIntoMesh(const std::string a_filename) noexcept;
 
  template <typename T, typename Meta = DCEL::DefaultMetaData>
  inline static std::vector<std::shared_ptr<MeshSDF<T, Meta>>>
  readIntoMesh(const std::vector<std::string> a_files) noexcept;
 
  template <typename T,
            typename Meta = DCEL::DefaultMetaData,
            typename BV   = EBGeometry::BoundingVolumes::AABBT<T>,
            size_t K      = 4>
  inline static std::shared_ptr<FastMeshSDF<T, Meta, BV, K>>
  readIntoFullBVH(const std::string a_filename) noexcept;
 
  template <typename T,
            typename Meta = DCEL::DefaultMetaData,
            typename BV   = EBGeometry::BoundingVolumes::AABBT<T>,
            size_t K      = 4>
  inline static std::vector<std::shared_ptr<FastMeshSDF<T, Meta, BV, K>>>
  readIntoFullBVH(const std::vector<std::string> a_files) noexcept;
 
  template <typename T,
            typename Meta = DCEL::DefaultMetaData,
            typename BV   = EBGeometry::BoundingVolumes::AABBT<T>,
            size_t K      = 4>
  inline static std::shared_ptr<FastCompactMeshSDF<T, Meta, BV, K>>
  readIntoLinearBVH(const std::string a_filename) noexcept;
 
  template <typename T,
            typename Meta = DCEL::DefaultMetaData,
            typename BV   = EBGeometry::BoundingVolumes::AABBT<T>,
            size_t K      = 4>
  inline static std::vector<std::shared_ptr<FastCompactMeshSDF<T, Meta, BV, K>>>
  readIntoLinearBVH(const std::vector<std::string> a_files) noexcept;
 
  inline static Parser::FileType
  getFileType(const std::string a_filename) noexcept;
 
  template <typename T>
  inline static bool
  containsDegeneratePolygons(const std::vector<EBGeometry::Vec3T<T>>& a_vertices,
                             const std::vector<std::vector<size_t>>&  a_facets) noexcept;
 
  template <typename T>
  inline static void
  compress(std::vector<EBGeometry::Vec3T<T>>& a_vertices, std::vector<std::vector<size_t>>& a_facets) noexcept;
 
  template <typename T, typename Meta>
  inline static void
  soupToDCEL(EBGeometry::DCEL::MeshT<T, Meta>&        a_mesh,
             const std::vector<EBGeometry::Vec3T<T>>& a_vertices,
             const std::vector<std::vector<size_t>>&  a_facets) noexcept;
 
  template <typename T, typename Meta>
  inline static void
  reconcilePairEdgesDCEL(std::vector<std::shared_ptr<EBGeometry::DCEL::EdgeT<T, Meta>>>& a_edges) noexcept;
 
  template <typename T, typename Meta>
  class STL
  {
  public:
    using Vec3 = EBGeometry::Vec3T<T>;
 
    using Vertex = EBGeometry::DCEL::VertexT<T, Meta>;
 
    using Edge = EBGeometry::DCEL::EdgeT<T, Meta>;
 
    using Face = EBGeometry::DCEL::FaceT<T, Meta>;
 
    using Mesh = EBGeometry::DCEL::MeshT<T, Meta>;
 
    using EdgeIterator = EBGeometry::DCEL::EdgeIteratorT<T, Meta>;
 
    inline static std::shared_ptr<Mesh>
    readSingle(const std::string a_filename) noexcept;
 
    inline static std::vector<std::pair<std::shared_ptr<Mesh>, std::string>>
    readMulti(const std::string a_filename) noexcept;
 
  protected:
    inline static Encoding
    getEncoding(const std::string a_filename) noexcept;
 
    inline static std::vector<std::pair<std::shared_ptr<Mesh>, std::string>>
    readASCII(const std::string a_filename) noexcept;
 
    inline static std::vector<std::pair<std::shared_ptr<Mesh>, std::string>>
    readBinary(const std::string a_filename) noexcept;
 
    inline static void
    readSTLSoupASCII(std::vector<Vec3>&                a_vertices,
                     std::vector<std::vector<size_t>>& a_facets,
                     std::string&                      a_objectName,
                     const std::vector<std::string>&   a_fileContents,
                     const size_t                      a_firstLine,
                     const size_t                      a_lastLine) noexcept;
  };
 
  template <typename T>
  class PLY
  {
  public:
    using Vec3 = EBGeometry::Vec3T<T>;
 
    using Vertex = EBGeometry::DCEL::VertexT<T>;
 
    using Edge = EBGeometry::DCEL::EdgeT<T>;
 
    using Face = EBGeometry::DCEL::FaceT<T>;
 
    using Mesh = EBGeometry::DCEL::MeshT<T>;
 
    using EdgeIterator = EBGeometry::DCEL::EdgeIteratorT<T>;
 
    inline static std::shared_ptr<Mesh>
    read(const std::string a_filename) noexcept;
 
  protected:
    inline static Encoding
    getEncoding(const std::string a_filename) noexcept;
 
    inline static void
    readPLYSoupASCII(std::vector<Vec3>&                a_vertices,
                     std::vector<std::vector<size_t>>& a_faces,
                     std::ifstream&                    a_fileStream) noexcept;
 
    inline static void
    readPLYSoupBinary(std::vector<Vec3>&                a_vertices,
                      std::vector<std::vector<size_t>>& a_faces,
                      std::ifstream&                    a_fileStream) noexcept;
  };
} // namespace Parser
 
#include "EBGeometry_NamespaceFooter.hpp"
 
#include "EBGeometry_ParserImplem.hpp"
 
#endif