EBGeometry_DCEL_Face.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_FACE_HPP
#define EBGEOMETRY_DCEL_FACE_HPP
 
// Std includes
#include <cstddef>
#include <cstdint>
#include <type_traits>
#include <vector>
 
// Our includes
#include "EBGeometry_DCEL.hpp"
#include "EBGeometry_DCEL_Edge.hpp"
#include "EBGeometry_DCEL_Vertex.hpp"
#include "EBGeometry_GPU.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
namespace DCEL {
 
template <class T>
class FaceT
{
  static_assert(std::is_floating_point_v<T>, "FaceT requires a floating-point T");
 
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>;
 
  FaceT() = default;
 
  EBGEOMETRY_HOST_DEVICE
  FaceT(const uint32_t a_edgeIndex);
 
  FaceT(const Face& a_otherFace) = default;
 
  FaceT(Face&& a_otherFace) = default;
 
  ~FaceT() = default;
 
  Face&
  operator=(const Face& a_otherFace) = default;
 
  Face&
  operator=(Face&& a_otherFace) = default;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  define(const Vec3& a_normal, const uint32_t a_edgeIndex) noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  reconcile(const Mesh& a_mesh);
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline uint32_t
  numVertices(const Mesh& a_mesh) const noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  computeProjectionDirections() noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  flipNormal() noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  setHalfEdge(const uint32_t a_halfEdgeIndex) noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  setInsideOutsideAlgorithm(InsideOutsideAlgorithm a_algorithm) noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline uint32_t
  getHalfEdgeIndex() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Vec3T<T>&
  getCentroid() noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline const Vec3T<T>&
  getCentroid() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T&
  getCentroid(const size_t a_dir) noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline const T&
  getCentroid(const size_t a_dir) 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 T&
  getArea() noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline const T&
  getArea() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  signedDistance(const Vec3& a_x0, const Mesh& a_mesh) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  rayCrossing(const Vec3& a_origin, const Vec3& a_direction, T a_tMin, T a_tMax, const Mesh& a_mesh) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  unsignedDistance2(const Vec3& a_x0, const Mesh& a_mesh) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline std::vector<Vec3T<T>>
  getAllVertexCoordinates(const Mesh& a_mesh) const;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline std::vector<uint32_t>
  gatherVertexIndices(const Mesh& a_mesh) const;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline std::vector<uint32_t>
  gatherEdgeIndices(const Mesh& a_mesh) const;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Vec3T<T>
  getSmallestCoordinate(const Mesh& a_mesh) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Vec3T<T>
  getHighestCoordinate(const Mesh& a_mesh) const noexcept;
 
protected:
  uint32_t m_halfEdge = UINT32_MAX;
 
  Vec3 m_normal = Vec3::zeros();
 
  Vec3 m_centroid = Vec3::zeros();
 
  T m_area{T(0)};
 
  uint32_t m_xDir = UINT32_MAX;
 
  uint32_t m_yDir = UINT32_MAX;
 
  InsideOutsideAlgorithm m_insideOutsideAlgorithm = InsideOutsideAlgorithm::CrossingNumber;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  computeCentroid(const Mesh& a_mesh);
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  computeNormal(const Mesh& a_mesh);
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  computeArea(const Mesh& a_mesh);
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  normalizeNormalVector() noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Vec3T<T>
  projectPointIntoFacePlane(const Vec3& a_p) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline bool
  isPointInsideFace(const Vec3& a_p, const Mesh& a_mesh) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Vec2T<T>
  projectPoint(const Vec3& a_point) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline int
  computeWindingNumber(const Vec2T<T>& a_point, const Mesh& a_mesh) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline size_t
  computeCrossingNumber(const Vec2T<T>& a_point, const Mesh& a_mesh) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  computeSubtendedAngle(const Vec2T<T>& a_point, const Mesh& a_mesh) const noexcept;
};
 
static_assert(std::is_trivially_copyable_v<FaceT<float>>, "FaceT<float> must be trivially copyable");
static_assert(std::is_trivially_copyable_v<FaceT<double>>, "FaceT<double> must be trivially copyable");
 
} // namespace DCEL
 
} // namespace EBGeometry
 
#include "EBGeometry_DCEL_FaceImplem.hpp"
 
#endif