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 <cmath>
#include <cstdint>
#include <type_traits>
#include <vector>
 
// Our includes
#include "EBGeometry_DCEL.hpp"
#include "EBGeometry_DCEL_Face.hpp"
#include "EBGeometry_GPU.hpp"
#include "EBGeometry_Math.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
namespace DCEL {
 
template <class T>
class VertexT
{
  static_assert(std::is_floating_point_v<T>, "VertexT<T>: T must be a floating-point type");
 
public:
  using Vec3 = Vec3T<T>;
 
  using Vertex = VertexT<T>;
 
  using Edge = EdgeT<T>;
 
  using Face = FaceT<T>;
 
  using Mesh = MeshT<T>;
 
  using EdgeIterator = EdgeIteratorT<T>;
 
  VertexT() = default;
 
  EBGEOMETRY_HOST_DEVICE
  VertexT(const Vec3& a_position);
 
  EBGEOMETRY_HOST_DEVICE
  VertexT(const Vec3& a_position, const Vec3& a_normal);
 
  VertexT(const Vertex& a_otherVertex) = default;
 
  VertexT(Vertex&& a_otherVertex) = default;
 
  ~VertexT() = default;
 
  Vertex&
  operator=(const Vertex& a_otherVertex) = default;
 
  Vertex&
  operator=(Vertex&& a_otherVertex) = default;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  define(const Vec3& a_position, const uint32_t a_edgeIndex, const Vec3& a_normal) noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  setPosition(const Vec3& a_position) noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  setNormal(const Vec3& a_normal) noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  setEdge(const uint32_t a_edgeIndex) noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  normalizeNormalVector() noexcept;
 
  EBGEOMETRY_HOST
  inline void
  computeVertexNormalAngleWeighted(const uint32_t               a_thisVertexIndex,
                                   const std::vector<uint32_t>& a_faceIndices,
                                   const Mesh&                  a_mesh);
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  flipNormal() noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Vec3T<T>&
  getPosition() noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline const Vec3T<T>&
  getPosition() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Vec3T<T>&
  getNormal() noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline const Vec3T<T>&
  getNormal() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline uint32_t
  getOutgoingEdgeIndex() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Edge&
  getOutgoingEdge(Mesh& a_mesh) noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline const Edge&
  getOutgoingEdge(const Mesh& a_mesh) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  signedDistance(const Vec3& a_x0) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  unsignedDistance2(const Vec3& a_x0) const noexcept;
 
protected:
  uint32_t m_outgoingEdge = UINT32_MAX;
 
  Vec3 m_position = Vec3::zeros();
 
  Vec3 m_normal = Vec3::zeros();
};
 
static_assert(std::is_trivially_copyable_v<VertexT<float>>, "VertexT<float> must be trivially copyable");
static_assert(std::is_trivially_copyable_v<VertexT<double>>, "VertexT<double> must be trivially copyable");
 
namespace VertexDetail {
 
template <class T>
EBGEOMETRY_HOST_DEVICE
inline Vec3T<T>
angleWeightedTerm(const Vec3T<T>& a_x0, const Vec3T<T>& a_x1, const Vec3T<T>& a_x2, const Vec3T<T>& a_normal) noexcept
{
  Vec3T<T> v1 = a_x1 - a_x0;
  Vec3T<T> v2 = a_x2 - a_x0;
 
  v1 = v1 / v1.length();
  v2 = v2 / v2.length();
 
  // Clamp to [-1,1] to guard against std::acos(NaN) from floating-point rounding.
  const T alpha = std::acos(Math::clamp(v1.dot(v2), T(-1), T(1)));
 
  return alpha * a_normal;
}
 
} // namespace VertexDetail
 
} // namespace DCEL
 
} // namespace EBGeometry
 
#include "EBGeometry_DCEL_VertexImplem.hpp"
 
#endif