EBGeometry_DCEL_Vertex.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_VERTEX_HPP
#define EBGEOMETRY_DCEL_VERTEX_HPP
 
// Std includes
#include <memory>
#include <type_traits>
#include <vector>
 
// Our includes
#include "EBGeometry_DCEL.hpp"
#include "EBGeometry_DCEL_Face.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
namespace DCEL {
 
template <class T, class Meta>
class VertexT
{
  static_assert(std::is_floating_point_v<T>, "VertexT<T,Meta>: T must be a floating-point type");
 
public:
  using Vec3 = Vec3T<T>;
 
  using Vertex = VertexT<T, Meta>;
 
  using Edge = EdgeT<T, Meta>;
 
  using Face = FaceT<T, Meta>;
 
  using VertexPtr = std::shared_ptr<Vertex>;
 
  using EdgePtr = std::shared_ptr<Edge>;
 
  using FacePtr = std::shared_ptr<Face>;
 
  using EdgeIterator = EdgeIteratorT<T, Meta>;
 
  VertexT() = default;
 
  VertexT(const Vec3& a_position);
 
  VertexT(const Vec3& a_position, const Vec3& a_normal);
 
  VertexT(const Vertex& a_otherVertex);
 
  VertexT(Vertex&& a_otherVertex) = default;
 
  ~VertexT() = default;
 
  Vertex&
  operator=(const Vertex& a_otherVertex);
 
  Vertex&
  operator=(Vertex&& a_otherVertex) = default;
 
  inline void
  define(const Vec3& a_position, const EdgePtr& a_edge, const Vec3& a_normal) noexcept;
 
  inline void
  setPosition(const Vec3& a_position) noexcept;
 
  inline void
  setNormal(const Vec3& a_normal) noexcept;
 
  inline void
  setEdge(const EdgePtr& a_edge) noexcept;
 
  inline void
  setMetaData(const Meta& a_metaData) noexcept;
 
  inline void
  addFace(const FacePtr& a_face);
 
  inline void
  normalizeNormalVector() noexcept;
 
  inline void
  computeVertexNormalAverage() noexcept;
 
  inline void
  computeVertexNormalAverage(const std::vector<FacePtr>& a_faces) noexcept;
 
  inline void
  computeVertexNormalAngleWeighted();
 
  inline void
  computeVertexNormalAngleWeighted(const std::vector<FacePtr>& a_faces);
 
  inline void
  flipNormal() noexcept;
 
  [[nodiscard]] inline Vec3T<T>&
  getPosition() noexcept;
 
  [[nodiscard]] inline const Vec3T<T>&
  getPosition() const noexcept;
 
  [[nodiscard]] inline Vec3T<T>&
  getNormal() noexcept;
 
  [[nodiscard]] inline const Vec3T<T>&
  getNormal() const noexcept;
 
  [[nodiscard]] inline EdgePtr
  getOutgoingEdge() noexcept;
 
  [[nodiscard]] inline EdgePtr
  getOutgoingEdge() 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
  unsignedDistance2(const Vec3& a_x0) const noexcept;
 
  [[nodiscard]] inline Meta&
  getMetaData() noexcept;
 
  [[nodiscard]] inline const Meta&
  getMetaData() const noexcept;
 
protected:
  std::weak_ptr<Edge> m_outgoingEdge;
 
  Vec3 m_position;
 
  Vec3 m_normal;
 
  std::vector<FacePtr> m_faces;
 
  Meta m_metaData{};
};
} // namespace DCEL
 
} // namespace EBGeometry
 
#include "EBGeometry_DCEL_VertexImplem.hpp"
 
#endif