EBGeometry_MeshDistanceFunctions.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 Robert Marskar <robert.marskar@sintef.no>
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef EBGEOMETRY_MESHDISTANCEFUNCTIONS_HPP
#define EBGEOMETRY_MESHDISTANCEFUNCTIONS_HPP
 
// Std includes
#include <cstddef>
#include <cstdint>
#include <limits>
#include <memory>
#include <type_traits>
#include <utility>
#include <vector>
 
// Our includes
#include "EBGeometry_BVH.hpp"
#include "EBGeometry_BoundingVolumes.hpp"
#include "EBGeometry_DCEL_Mesh.hpp"
#include "EBGeometry_SignedDistanceFunction.hpp"
#include "EBGeometry_Triangle.hpp"
#include "EBGeometry_TriangleAoSoA.hpp"
#include "EBGeometry_TriangleSoA.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
template <class T, class Meta = DCEL::DefaultMetaData>
class FlatMeshSDF : public SignedDistanceFunction<T>
{
  static_assert(std::is_floating_point_v<T>, "FlatMeshSDF requires a floating-point T");
 
public:
  using Mesh = EBGeometry::DCEL::MeshT<T, Meta>;
 
  FlatMeshSDF() = delete;
 
  FlatMeshSDF(const std::shared_ptr<Mesh>& a_mesh) noexcept;
 
  ~FlatMeshSDF() override = default;
 
  FlatMeshSDF(const FlatMeshSDF& a_other) = default;
 
  FlatMeshSDF&
  operator=(const FlatMeshSDF& a_other) = default;
 
  FlatMeshSDF(FlatMeshSDF&& a_other) noexcept = default;
 
  FlatMeshSDF&
  operator=(FlatMeshSDF&& a_other) noexcept = default;
 
  [[nodiscard]] T
  signedDistance(const Vec3T<T>& a_point) const noexcept override;
 
  [[nodiscard]] const std::shared_ptr<Mesh>
  getMesh() const noexcept;
 
  template <class BV>
  [[nodiscard]] BV
  computeBoundingVolume() const;
 
protected:
  std::shared_ptr<Mesh> m_mesh;
};
 
template <class T, class Meta, size_t K>
class MeshSDF : public SignedDistanceFunction<T>
{
  static_assert(std::is_floating_point_v<T>, "MeshSDF requires a floating-point T");
  static_assert(K >= 2, "MeshSDF requires branching factor K >= 2");
 
public:
  using Face = typename EBGeometry::DCEL::FaceT<T, Meta>;
 
  using Mesh = typename EBGeometry::DCEL::MeshT<T, Meta>;
 
  using Root = EBGeometry::BVH::PackedBVH<T, Face, K>;
 
  using Node = typename Root::Node;
 
  MeshSDF() = delete;
 
  MeshSDF(const std::shared_ptr<Mesh>& a_mesh, const BVH::Build a_build);
 
  ~MeshSDF() override = default;
 
  MeshSDF(const MeshSDF& a_other) = default;
 
  MeshSDF&
  operator=(const MeshSDF& a_other) = default;
 
  MeshSDF(MeshSDF&& a_other) noexcept = default;
 
  MeshSDF&
  operator=(MeshSDF&& a_other) noexcept = default;
 
  [[nodiscard]] T
  signedDistance(const Vec3T<T>& a_point) const noexcept override;
 
  [[nodiscard]] virtual std::vector<std::pair<std::shared_ptr<const Face>, T>>
  getClosestFaces(const Vec3T<T>& a_point, const bool a_sorted) const;
 
  [[nodiscard]] virtual std::shared_ptr<Root>&
  getRoot() noexcept;
 
  [[nodiscard]] virtual const std::shared_ptr<Root>&
  getRoot() const noexcept;
 
  [[nodiscard]] EBGeometry::BoundingVolumes::AABBT<T>
  computeBoundingVolume() const noexcept;
 
protected:
  std::shared_ptr<Root> m_bvh;
 
  std::shared_ptr<Mesh> m_mesh;
};
 
template <class T,
          class Meta,
          size_t K,
          size_t W,
          class StoragePolicy = BVH::ValueStorage<EBGeometry::TriangleAoSoA<T, Meta, W>>>
class TriMeshSDF : public SignedDistanceFunction<T>
{
  static_assert(std::is_floating_point_v<T>, "TriMeshSDF<T,Meta,K,W> requires a floating-point T");
  static_assert(K >= 2, "TriMeshSDF requires branching factor K >= 2");
  static_assert(W > 0, "TriMeshSDF requires SoA width W > 0");
 
public:
  using Mesh = EBGeometry::DCEL::MeshT<T, Meta>;
 
  using Tri = typename EBGeometry::Triangle<T, Meta>;
 
  using TriAoSoA = TriangleAoSoA<T, Meta, W>;
 
  using Root = typename EBGeometry::BVH::PackedBVH<T, TriAoSoA, K, StoragePolicy>;
 
  struct ClosestTriangle
  {
    T    signedDistance = std::numeric_limits<T>::max(); 
    Meta metaData{};                                     
  };
 
  TriMeshSDF() = delete;
 
  TriMeshSDF(const std::shared_ptr<Mesh>& a_mesh, const BVH::Build a_build, const size_t a_maxLeafGroups) noexcept;
 
  TriMeshSDF(const std::vector<std::shared_ptr<Tri>>& a_triangles,
             const BVH::Build                         a_build,
             const size_t                             a_maxLeafGroups) noexcept;
 
  ~TriMeshSDF() override = default;
 
  TriMeshSDF(const TriMeshSDF& a_other) = default;
 
  TriMeshSDF&
  operator=(const TriMeshSDF& a_other) = default;
 
  TriMeshSDF(TriMeshSDF&& a_other) noexcept = default;
 
  TriMeshSDF&
  operator=(TriMeshSDF&& a_other) noexcept = default;
 
  [[nodiscard]] T
  signedDistance(const Vec3T<T>& a_point) const noexcept override;
 
  [[nodiscard]] ClosestTriangle
  getClosestTriangle(const Vec3T<T>& a_point) const noexcept;
 
  [[nodiscard]] virtual std::shared_ptr<Root>&
  getRoot() noexcept;
 
  [[nodiscard]] virtual const std::shared_ptr<Root>&
  getRoot() const noexcept;
 
  [[nodiscard]] EBGeometry::BoundingVolumes::AABBT<T>
  computeBoundingVolume() const noexcept;
 
protected:
  std::shared_ptr<Root> m_bvh;
 
  [[nodiscard]] static std::vector<TriAoSoA>
  groupTrianglesIntoSoA(const std::vector<std::shared_ptr<const Tri>>& a_triangles,
                        uint32_t                                       a_offset,
                        uint32_t                                       a_count);
};
 
} // namespace EBGeometry
 
#include "EBGeometry_MeshDistanceFunctionsImplem.hpp"
 
#endif