EBGeometry_CSG.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_CSG_HPP
#define EBGEOMETRY_CSG_HPP
 
// Std includes
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <functional>
#include <memory>
#include <type_traits>
#include <utility>
#include <vector>
 
// Our includes
#include "EBGeometry_BVH.hpp"
#include "EBGeometry_ImplicitFunction.hpp"
#include "EBGeometry_Macros.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
template <class T, class P = ImplicitFunction<T>>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Union(const std::vector<std::shared_ptr<P>>& a_implicitFunctions);
 
template <class T, class P1, class P2>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Union(const std::shared_ptr<P1>& a_implicitFunctionA, const std::shared_ptr<P2>& a_implicitFunctionB);
 
template <class T, class P = ImplicitFunction<T>>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
SmoothUnion(const std::vector<std::shared_ptr<P>>& a_implicitFunctions, const T a_smooth);
 
template <class T, class P1, class P2>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
SmoothUnion(const std::shared_ptr<P1>& a_implicitFunctionA,
            const std::shared_ptr<P2>& a_implicitFunctionB,
            const T                    a_smooth);
 
template <class T, class P, class BV, size_t K>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
BVHUnion(const std::vector<std::shared_ptr<P>>& a_implicitFunctions, const std::vector<BV>& a_boundingVolumes);
 
template <class T, class P, class BV, size_t K>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
BVHSmoothUnion(const std::vector<std::shared_ptr<P>>& a_implicitFunctions,
               const std::vector<BV>&                 a_boundingVolumes,
               const T                                a_smoothLen) noexcept;
 
template <class T, class P>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Intersection(const std::vector<std::shared_ptr<P>>& a_implicitFunctions);
 
template <class T, class P1, class P2>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Intersection(const std::shared_ptr<P1>& a_implicitFunctionA, const std::shared_ptr<P2>& a_implicitFunctionB);
 
template <class T, class P>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
SmoothIntersection(const std::vector<std::shared_ptr<P>>& a_implicitFunctions, const T a_smooth);
 
template <class T, class P1, class P2>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
SmoothIntersection(const std::shared_ptr<P1>& a_implicitFunctionA,
                   const std::shared_ptr<P2>& a_implicitFunctionB,
                   const T                    a_smooth);
 
template <class T, class P1 = ImplicitFunction<T>, class P2 = ImplicitFunction<T>>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Difference(const std::shared_ptr<P1>& a_implicitFunctionA, const std::shared_ptr<P2>& a_implicitFunctionB);
 
template <class T, class P1 = ImplicitFunction<T>, class P2 = ImplicitFunction<T>>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
SmoothDifference(const std::shared_ptr<P1>& a_implicitFunctionA,
                 const std::shared_ptr<P2>& a_implicitFunctionB,
                 const T                    a_smoothLen);
 
template <class T, class P = ImplicitFunction<T>>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
FiniteRepetition(const std::shared_ptr<P>& a_implicitFunction,
                 const Vec3T<T>&           a_period,
                 const Vec3T<T>&           a_repeatLo,
                 const Vec3T<T>&           a_repeatHi);
 
template <class T>
std::function<T(const T& a, const T& b, const T& s)> ExpMin = [](const T& a, const T& b, const T& s) -> T {
  static_assert(std::is_floating_point_v<T>, "ExpMin requires a floating-point type T");
 
  EBGEOMETRY_EXPECT(s > T(0));
  T ret = std::exp(-a / s) + std::exp(-b / s);
 
  return -std::log(ret) * s;
};
 
template <class T>
std::function<T(const T& a, const T& b, const T& s)> SmoothMin = [](const T& a, const T& b, const T& s) -> T {
  static_assert(std::is_floating_point_v<T>, "SmoothMin requires a floating-point type T");
 
  EBGEOMETRY_EXPECT(s > T(0));
  const T h = std::max(s - std::abs(a - b), T(0)) / s;
 
  return std::min(a, b) - T(0.25) * h * h * s;
};
 
template <class T>
std::function<T(const T& a, const T& b, const T& s)> SmoothMax = [](const T& a, const T& b, const T& s) -> T {
  static_assert(std::is_floating_point_v<T>, "SmoothMax requires a floating-point type T");
 
  EBGEOMETRY_EXPECT(s > T(0));
  const T h = std::max(s - std::abs(a - b), T(0)) / s;
 
  return std::max(a, b) + T(0.25) * h * h * s;
};
 
template <class T>
class UnionIF : public ImplicitFunction<T>
{
public:
  static_assert(std::is_floating_point_v<T>, "UnionIF requires a floating-point type T");
 
  UnionIF() = delete;
 
  UnionIF(const std::vector<std::shared_ptr<ImplicitFunction<T>>>& a_implicitFunctions);
 
  ~UnionIF() override = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::vector<std::shared_ptr<const ImplicitFunction<T>>> m_implicitFunctions;
};
 
template <class T>
class SmoothUnionIF : public ImplicitFunction<T>
{
public:
  static_assert(std::is_floating_point_v<T>, "SmoothUnionIF requires a floating-point type T");
 
  SmoothUnionIF() = delete;
 
  SmoothUnionIF(const std::vector<std::shared_ptr<ImplicitFunction<T>>>&   a_implicitFunctions,
                const T                                                    a_smoothLen,
                const std::function<T(const T& a, const T& b, const T& s)> a_smoothMin = SmoothMin<T>);
 
  ~SmoothUnionIF() override = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::vector<std::shared_ptr<const ImplicitFunction<T>>> m_implicitFunctions;
 
  T m_smoothLen;
 
  std::function<T(const T&, const T&, const T&)> m_smoothMin;
};
 
template <class T, class P, class BV, size_t K>
class BVHUnionIF : public ImplicitFunction<T>
{
public:
  static_assert(std::is_floating_point_v<T>, "BVHUnionIF requires a floating-point type T");
  static_assert(std::is_base_of_v<EBGeometry::ImplicitFunction<T>, P>, "BVHUnionIF requires an implicit function");
  static_assert(K > 0, "BVHUnionIF BVH branching factor K must be positive");
 
  using Root = EBGeometry::BVH::PackedBVH<T, P, K>;
 
  using Node = typename Root::Node;
 
  BVHUnionIF() = delete;
 
  BVHUnionIF(const std::vector<std::pair<std::shared_ptr<const P>, BV>>& a_primsAndBVs);
 
  BVHUnionIF(const std::vector<std::shared_ptr<P>>& a_primitives, const std::vector<BV>& a_boundingVolumes);
 
  ~BVHUnionIF() override = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
  [[nodiscard]] const EBGeometry::BoundingVolumes::AABBT<T>&
  getBoundingVolume() const noexcept;
 
protected:
  std::shared_ptr<EBGeometry::BVH::PackedBVH<T, P, K>> m_bvh;
 
  inline void
  buildTree(const std::vector<std::pair<std::shared_ptr<const P>, BV>>& a_primsAndBVs,
            const BVH::Build                                            a_build = BVH::Build::SAH) noexcept;
};
 
template <class T, class P, class BV, size_t K>
class BVHSmoothUnionIF : public ImplicitFunction<T>
{
public:
  static_assert(std::is_floating_point_v<T>, "BVHSmoothUnionIF requires a floating-point type T");
  static_assert(std::is_base_of_v<EBGeometry::ImplicitFunction<T>, P>,
                "BVHSmoothUnionIF requires an implicit function");
  static_assert(K > 0, "BVHSmoothUnionIF BVH branching factor K must be positive");
 
  using Root = EBGeometry::BVH::PackedBVH<T, P, K>;
 
  using Node = typename Root::Node;
 
  BVHSmoothUnionIF() = delete;
 
  BVHSmoothUnionIF(const std::vector<std::shared_ptr<P>>&               a_distanceFunctions,
                   const std::vector<BV>&                               a_boundingVolumes,
                   const T                                              a_smoothLen,
                   const std::function<T(const T&, const T&, const T&)> a_smoothMin = SmoothMin<T>) noexcept;
 
  ~BVHSmoothUnionIF() override = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
  [[nodiscard]] const EBGeometry::BoundingVolumes::AABBT<T>&
  getBoundingVolume() const noexcept;
 
protected:
  std::shared_ptr<EBGeometry::BVH::PackedBVH<T, P, K>> m_bvh;
 
  T m_smoothLen;
 
  std::function<T(const T&, const T&, const T&)> m_smoothMin;
 
  inline void
  buildTree(const std::vector<std::pair<std::shared_ptr<const P>, BV>>& a_primsAndBVs,
            const BVH::Build                                            a_build = BVH::Build::SAH) noexcept;
};
 
template <class T>
class IntersectionIF : public ImplicitFunction<T>
{
public:
  static_assert(std::is_floating_point_v<T>, "IntersectionIF requires a floating-point type T");
 
  IntersectionIF() = delete;
 
  IntersectionIF(const std::vector<std::shared_ptr<ImplicitFunction<T>>>& a_implicitFunctions) noexcept;
 
  ~IntersectionIF() override = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::vector<std::shared_ptr<const ImplicitFunction<T>>> m_implicitFunctions;
};
 
template <class T>
class SmoothIntersectionIF : public ImplicitFunction<T>
{
public:
  static_assert(std::is_floating_point_v<T>, "SmoothIntersectionIF requires a floating-point type T");
 
  SmoothIntersectionIF() = delete;
 
  SmoothIntersectionIF(const std::shared_ptr<ImplicitFunction<T>>&                 a_implicitFunctionA,
                       const std::shared_ptr<ImplicitFunction<T>>&                 a_implicitFunctionB,
                       const T                                                     a_smoothLen,
                       const std::function<T(const T& a, const T& b, const T& s)>& a_smoothMax = SmoothMax<T>) noexcept;
 
  SmoothIntersectionIF(const std::vector<std::shared_ptr<ImplicitFunction<T>>>&    a_implicitFunctions,
                       const T                                                     a_smoothLen,
                       const std::function<T(const T& a, const T& b, const T& s)>& a_smoothMax = SmoothMax<T>) noexcept;
 
  ~SmoothIntersectionIF() override = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::vector<std::shared_ptr<const ImplicitFunction<T>>> m_implicitFunctions;
 
  T m_smoothLen;
 
  std::function<T(const T& a, const T& b, const T& s)> m_smoothMax;
};
 
template <class T>
class DifferenceIF : public ImplicitFunction<T>
{
public:
  static_assert(std::is_floating_point_v<T>, "DifferenceIF requires a floating-point type T");
 
  DifferenceIF() = delete;
 
  DifferenceIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunctionA,
               const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunctionB) noexcept;
 
  DifferenceIF(const std::shared_ptr<ImplicitFunction<T>>&              a_implicitFunctionA,
               const std::vector<std::shared_ptr<ImplicitFunction<T>>>& a_implicitFunctionsB) noexcept;
 
  ~DifferenceIF() override = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunctionA;
 
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunctionB;
};
 
template <class T>
class SmoothDifferenceIF : public ImplicitFunction<T>
{
public:
  static_assert(std::is_floating_point_v<T>, "SmoothDifferenceIF requires a floating-point type T");
 
  SmoothDifferenceIF() = delete;
 
  SmoothDifferenceIF(const std::shared_ptr<ImplicitFunction<T>>&                 a_implicitFunctionA,
                     const std::shared_ptr<ImplicitFunction<T>>&                 a_implicitFunctionB,
                     const T                                                     a_smoothLen,
                     const std::function<T(const T& a, const T& b, const T& s)>& a_smoothMax = SmoothMax<T>) noexcept;
 
  SmoothDifferenceIF(const std::shared_ptr<ImplicitFunction<T>>&                 a_implicitFunctionA,
                     const std::vector<std::shared_ptr<ImplicitFunction<T>>>&    a_implicitFunctionsB,
                     const T                                                     a_smoothLen,
                     const std::function<T(const T& a, const T& b, const T& s)>& a_smoothMax = SmoothMax<T>) noexcept;
 
  ~SmoothDifferenceIF() override = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<SmoothIntersectionIF<T>> m_smoothIntersectionIF;
};
 
template <class T>
class FiniteRepetitionIF : public ImplicitFunction<T>
{
public:
  static_assert(std::is_floating_point_v<T>, "FiniteRepetitionIF requires a floating-point type T");
 
  FiniteRepetitionIF() = delete;
 
  FiniteRepetitionIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction,
                     const Vec3T<T>&                             a_period,
                     const Vec3T<T>&                             a_repeatLo,
                     const Vec3T<T>&                             a_repeatHi) noexcept;
 
  ~FiniteRepetitionIF() override = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  Vec3T<T> m_period;
 
  Vec3T<T> m_repeatHi;
 
  Vec3T<T> m_repeatLo;
 
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction;
};
 
} // namespace EBGeometry
 
#include "EBGeometry_CSGImplem.hpp"
 
#endif