EBGeometry_DCEL_Mesh.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2022 Robert Marskar <robert.marskar@sintef.no>
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef EBGEOMETRY_DCEL_MESH_HPP
#define EBGEOMETRY_DCEL_MESH_HPP
 
// Std includes
#include <cstddef>
#include <map>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
 
// Our includes
#include "EBGeometry_DCEL.hpp"
#include "EBGeometry_Polygon2D.hpp"
 
namespace EBGeometry {
 
namespace DCEL {
 
template <class T, class Meta>
class MeshT
{
  static_assert(std::is_floating_point_v<T>, "MeshT requires a floating-point T");
 
public:
  enum class SearchAlgorithm
  {
    Direct, 
    Direct2 
  };
 
  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 = default;
 
  MeshT(const Mesh& a_otherMesh) = delete;
 
  MeshT(Mesh&& a_otherMesh) noexcept = default;
 
  MeshT(std::vector<FacePtr>& a_faces, std::vector<EdgePtr>& a_edges, std::vector<VertexPtr>& a_vertices) noexcept;
 
  ~MeshT() noexcept = default;
 
  Mesh&
  operator=(const Mesh& a_otherMesh) = delete;
 
  Mesh&
  operator=(Mesh&& a_otherMesh) noexcept = default;
 
  [[nodiscard]] inline std::shared_ptr<Mesh>
  deepCopy() const;
 
  inline void
  sanityCheck(const std::string a_id) const;
 
  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;
 
  [[nodiscard]] inline std::vector<VertexPtr>&
  getVertices() noexcept;
 
  [[nodiscard]] inline const std::vector<VertexPtr>&
  getVertices() const noexcept;
 
  [[nodiscard]] inline std::vector<Vec3T<T>>
  getAllVertexCoordinates() const noexcept;
 
  [[nodiscard]] inline std::vector<EdgePtr>&
  getEdges() noexcept;
 
  [[nodiscard]] inline const std::vector<EdgePtr>&
  getEdges() const noexcept;
 
  [[nodiscard]] inline std::vector<FacePtr>&
  getFaces() noexcept;
 
  [[nodiscard]] inline const std::vector<FacePtr>&
  getFaces() const noexcept;
 
  [[nodiscard]] inline T
  signedDistance(const Vec3& a_x0) const noexcept;
 
  [[nodiscard]] inline T
  signedDistance(const Vec3& a_x0, SearchAlgorithm a_algorithm) const noexcept;
 
  [[nodiscard]] inline T
  unsignedDistance2(const Vec3& a_x0) const noexcept;
 
protected:
  SearchAlgorithm m_algorithm = SearchAlgorithm::Direct2;
 
  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
  flipFaceNormals() noexcept;
 
  inline void
  flipEdgeNormals() noexcept;
 
  inline void
  flipVertexNormals() noexcept;
 
  [[nodiscard]] inline T
  DirectSignedDistance(const Vec3& a_point) const noexcept;
 
  [[nodiscard]] 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;
 
  inline void
  printWarnings(const std::map<std::string, size_t>& a_warnings, const std::string& a_id) const;
};
} // namespace DCEL
 
} // namespace EBGeometry
 
#include "EBGeometry_DCEL_MeshImplem.hpp"
 
#endif