EBGeometry_BoundingVolumes.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_BOUNDINGVOLUMES_HPP
#define EBGEOMETRY_BOUNDINGVOLUMES_HPP
 
// Std includes
#include <ostream>
#include <type_traits>
#include <vector>
 
// Our includes
#include "EBGeometry_Macros.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
namespace BoundingVolumes {
 
template <class T>
class SphereT
{
  static_assert(std::is_floating_point_v<T>, "SphereT<T>: T must be a floating-point type.");
 
public:
  friend std::ostream&
  operator<<(std::ostream& os, const SphereT<T>& sphere)
  {
    os << '(' << sphere.getCentroid() << ", " << sphere.getRadius() << ')';
 
    return os;
  }
 
  enum class BuildAlgorithm
  {
    Ritter, 
  };
 
  using Vec3 = Vec3T<T>;
 
  SphereT() noexcept = default;
 
  inline SphereT(const Vec3T<T>& a_center, const T& a_radius) noexcept;
 
  inline SphereT(const std::vector<SphereT<T>>& a_otherSpheres) noexcept;
 
  inline SphereT(const SphereT& a_other) noexcept;
 
  template <class P>
  inline SphereT(const std::vector<Vec3T<P>>& a_points, const BuildAlgorithm& a_alg = BuildAlgorithm::Ritter) noexcept;
 
  ~SphereT() noexcept;
 
  SphereT&
  operator=(const SphereT& a_other) = default;
 
  SphereT(SphereT&& a_other) noexcept = default;
 
  SphereT&
  operator=(SphereT&& a_other) noexcept = default;
 
  template <class P>
  inline void
  define(const std::vector<Vec3T<P>>& a_points, const BuildAlgorithm& a_alg) noexcept;
 
  [[nodiscard]] inline bool
  intersects(const SphereT& a_other) const noexcept;
 
  inline T&
  getRadius() noexcept;
 
  [[nodiscard]] inline const T&
  getRadius() const noexcept;
 
  inline Vec3&
  getCentroid() noexcept;
 
  [[nodiscard]] inline const Vec3&
  getCentroid() const noexcept;
 
  [[nodiscard]] inline T
  getOverlappingVolume(const SphereT<T>& a_other) const noexcept;
 
  [[nodiscard]] inline T
  getDistance(const Vec3& a_x0) const noexcept;
 
  [[nodiscard]] inline T
  getDistance2(const Vec3& a_x0) const noexcept;
 
  [[nodiscard]] inline T
  getVolume() const noexcept;
 
  [[nodiscard]] inline T
  getArea() const noexcept;
 
protected:
  T m_radius = T(-1);
 
  Vec3 m_center = Vec3::zeros();
 
  template <class P>
  inline void
  buildRitter(const std::vector<Vec3T<P>>& a_points) noexcept;
};
 
template <class T>
class AABBT
{
  static_assert(std::is_floating_point_v<T>, "AABBT<T>: T must be a floating-point type.");
 
public:
  friend std::ostream&
  operator<<(std::ostream& os, const AABBT<T>& aabb)
  {
    os << '(' << aabb.getLowCorner() << ", " << aabb.getHighCorner() << ')';
 
    return os;
  }
 
  using Vec3 = Vec3T<T>;
 
  AABBT() noexcept = default;
 
  inline AABBT(const Vec3T<T>& a_lo, const Vec3T<T>& a_hi) noexcept;
 
  inline AABBT(const AABBT& a_other) noexcept;
 
  inline AABBT(const std::vector<AABBT<T>>& a_others) noexcept;
 
  template <class P>
  inline AABBT(const std::vector<Vec3T<P>>& a_points) noexcept;
 
  ~AABBT() noexcept;
 
  AABBT&
  operator=(const AABBT<T>& a_other) = default;
 
  AABBT(AABBT&& a_other) noexcept = default;
 
  AABBT&
  operator=(AABBT&& a_other) noexcept = default;
 
  template <class P>
  inline void
  define(const std::vector<Vec3T<P>>& a_points) noexcept;
 
  [[nodiscard]] inline bool
  intersects(const AABBT& a_other) const noexcept;
 
  inline Vec3T<T>&
  getLowCorner() noexcept;
 
  [[nodiscard]] inline const Vec3T<T>&
  getLowCorner() const noexcept;
 
  inline Vec3T<T>&
  getHighCorner() noexcept;
 
  [[nodiscard]] inline const Vec3T<T>&
  getHighCorner() const noexcept;
 
  [[nodiscard]] inline Vec3
  getCentroid() const noexcept;
 
  [[nodiscard]] inline T
  getOverlappingVolume(const AABBT<T>& a_other) const noexcept;
 
  [[nodiscard]] inline T
  getDistance(const Vec3& a_x0) const noexcept;
 
  [[nodiscard]] inline T
  getDistance2(const Vec3& a_x0) const noexcept;
 
  [[nodiscard]] inline T
  getVolume() const noexcept;
 
  [[nodiscard]] inline T
  getArea() const noexcept;
 
protected:
  Vec3 m_loCorner = Vec3::infinity();
 
  Vec3 m_hiCorner = -Vec3::infinity();
};
 
template <class T>
[[nodiscard]] bool
intersects(const SphereT<T>& a_u, const SphereT<T>& a_v) noexcept;
 
template <class T>
[[nodiscard]] bool
intersects(const AABBT<T>& a_u, const AABBT<T>& a_v) noexcept;
 
template <class T>
[[nodiscard]] T
getOverlappingVolume(const SphereT<T>& a_u, const SphereT<T>& a_v) noexcept;
 
template <class T>
[[nodiscard]] T
getOverlappingVolume(const AABBT<T>& a_u, const AABBT<T>& a_v) noexcept;
} // namespace BoundingVolumes
 
} // namespace EBGeometry
 
#include "EBGeometry_BoundingVolumesImplem.hpp"
 
#endif