EBGeometry_DCEL_Mesh.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_DCEL_Mesh
#define EBGeometry_DCEL_Mesh
 
// Std includes
#include <vector>
#include <memory>
#include <functional>
#include <map>
 
// Our includes
#include "EBGeometry_DCEL.hpp"
#include "EBGeometry_Polygon2D.hpp"
#include "EBGeometry_NamespaceHeader.hpp"
 
namespace DCEL {
 
  template <class T, class Meta>
  class MeshT
  {
  public:
    enum class SearchAlgorithm
    {
      Direct,
      Direct2,
    };
 
    enum class VertexNormalWeight
    {
      None,
      Angle,
    };
 
    using Vec3 = Vec3T<T>;
 
    using Vertex = VertexT<T, Meta>;
 
    using Edge = EdgeT<T, Meta>;
 
    using Face = FaceT<T, Meta>;
 
    using Mesh = MeshT<T, Meta>;
 
    using VertexPtr = std::shared_ptr<Vertex>;
 
    using EdgePtr = std::shared_ptr<Edge>;
 
    using FacePtr = std::shared_ptr<Face>;
 
    MeshT() noexcept;
 
    MeshT(const Mesh& a_otherMesh) = delete;
 
    MeshT(std::vector<FacePtr>& a_faces, std::vector<EdgePtr>& a_edges, std::vector<VertexPtr>& a_vertices) noexcept;
 
    virtual ~MeshT() noexcept;
 
    inline void
    define(std::vector<FacePtr>& a_faces, std::vector<EdgePtr>& a_edges, std::vector<VertexPtr>& a_vertices) noexcept;
 
    inline void
    sanityCheck() const noexcept;
 
    inline void
    setSearchAlgorithm(const SearchAlgorithm a_algorithm) noexcept;
 
    inline void
    setInsideOutsideAlgorithm(typename Polygon2D<T>::InsideOutsideAlgorithm a_algorithm) noexcept;
 
    inline void
    reconcile(const DCEL::VertexNormalWeight a_weight = DCEL::VertexNormalWeight::Angle) noexcept;
 
    inline void
    flip() noexcept;
 
    inline std::vector<VertexPtr>&
    getVertices() noexcept;
 
    inline const std::vector<VertexPtr>&
    getVertices() const noexcept;
 
    inline std::vector<Vec3T<T>>
    getAllVertexCoordinates() const noexcept;
 
    inline std::vector<EdgePtr>&
    getEdges() noexcept;
 
    inline const std::vector<EdgePtr>&
    getEdges() const noexcept;
 
    inline std::vector<FacePtr>&
    getFaces() noexcept;
 
    inline const std::vector<FacePtr>&
    getFaces() const noexcept;
 
    inline T
    signedDistance(const Vec3& a_x0) const noexcept;
 
    inline T
    signedDistance(const Vec3& a_x0, SearchAlgorithm a_algorithm) const noexcept;
 
    inline T
    unsignedDistance2(const Vec3& a_x0) const noexcept;
 
  protected:
    SearchAlgorithm m_algorithm;
 
    std::vector<VertexPtr> m_vertices;
 
    std::vector<EdgePtr> m_edges;
 
    std::vector<FacePtr> m_faces;
 
    inline void
    reconcileFaces() noexcept;
 
    inline void
    reconcileEdges() noexcept;
 
    inline void
    reconcileVertices(const DCEL::VertexNormalWeight a_weight) noexcept;
 
    inline void
    flipFaces() noexcept;
 
    inline void
    flipEdges() noexcept;
 
    inline void
    flipVertices() noexcept;
 
    inline T
    DirectSignedDistance(const Vec3& a_point) const noexcept;
 
    inline T
    DirectSignedDistance2(const Vec3& a_point) const noexcept;
 
    inline void
    incrementWarning(std::map<std::string, size_t>& a_warnings, const std::string& a_warn) const noexcept;
 
    inline void
    printWarnings(const std::map<std::string, size_t>& a_warnings) const noexcept;
  };
} // namespace DCEL
 
#include "EBGeometry_NamespaceFooter.hpp"
 
#include "EBGeometry_DCEL_MeshImplem.hpp"
 
#endif