EBGeometry_CSG.hpp

Go to the documentation of this file.

/* EBGeometry
 * Copyright © 2022 Robert Marskar
 * Please refer to Copyright.txt and LICENSE in the EBGeometry root directory.
 */
 
#ifndef EBGeometry_CSG
#define EBGeometry_CSG
 
// Std includes
#include <vector>
#include <type_traits>
 
// Our includes
#include "EBGeometry_ImplicitFunction.hpp"
#include "EBGeometry_NamespaceHeader.hpp"
 
template <class T, class P = ImplicitFunction<T>>
std::shared_ptr<ImplicitFunction<T>>
Union(const std::vector<std::shared_ptr<P>>& a_implicitFunctions) noexcept;
 
template <class T, class P1, class P2>
std::shared_ptr<ImplicitFunction<T>>
Union(const std::shared_ptr<P1>& a_implicitFunctionA, const std::shared_ptr<P2>& a_implicitFunctionB) noexcept;
 
template <class T, class P = ImplicitFunction<T>>
std::shared_ptr<ImplicitFunction<T>>
SmoothUnion(const std::vector<std::shared_ptr<P>>& a_implicitFunctions, const T a_smooth) noexcept;
 
template <class T, class P1, class P2>
std::shared_ptr<ImplicitFunction<T>>
SmoothUnion(const std::shared_ptr<P1>& a_implicitFunctionA,
            const std::shared_ptr<P2>& a_implicitFunctionB,
            const T                    a_smooth) noexcept;
 
template <class T, class P, class BV, size_t K>
std::shared_ptr<ImplicitFunction<T>>
FastUnion(const std::vector<std::shared_ptr<P>>& a_implicitFunctions,
          const std::vector<BV>&                 a_boundingVolumes) noexcept;
 
template <class T, class P, class BV, size_t K>
std::shared_ptr<ImplicitFunction<T>>
FastSmoothUnion(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>
std::shared_ptr<ImplicitFunction<T>>
Intersection(const std::vector<std::shared_ptr<P>>& a_implicitFunctions) noexcept;
 
template <class T, class P1, class P2>
std::shared_ptr<ImplicitFunction<T>>
Intersection(const std::shared_ptr<std::shared_ptr<P1>>& a_implicitFunctionA,
             const std::shared_ptr<std::shared_ptr<P2>>& a_implicitFunctionB) noexcept;
 
template <class T, class P>
std::shared_ptr<ImplicitFunction<T>>
SmoothIntersection(const std::vector<std::shared_ptr<P>>& a_implicitFunctions, const T a_smooth) noexcept;
 
template <class T, class P1, class P2>
std::shared_ptr<ImplicitFunction<T>>
SmoothIntersection(const std::shared_ptr<P1>& a_implicitFunctionA,
                   const std::shared_ptr<P2>& a_implicitFunctionB,
                   const T                    a_smooth) noexcept;
 
template <class T, class P1 = ImplicitFunction<T>, class P2 = ImplicitFunction<T>>
std::shared_ptr<ImplicitFunction<T>>
Difference(const std::shared_ptr<P1>& a_implicitFunctionA, const std::shared_ptr<P2>& a_implicitFunctionB) noexcept;
 
template <class T, class P1 = ImplicitFunction<T>, class P2 = ImplicitFunction<T>>
std::shared_ptr<ImplicitFunction<T>>
SmoothDifference(const std::shared_ptr<P1>& a_implicitFunctionA,
                 const std::shared_ptr<P2>& a_implicitFunctionB,
                 const T                    a_smoothLen) noexcept;
 
template <class T, class P = ImplicitFunction<T>>
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) noexcept;
 
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 {
  T ret = exp(-a / s) + exp(-b / s);
 
  return -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 {
  const T h = std::max(s - std::abs(a - b), 0.0) / s;
 
  return std::min(a, b) - 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 {
  const T h = std::max(s - std::abs(a - b), 0.0) / s;
 
  return std::max(a, b) + 0.25 * h * h * s;
};
 
template <class T>
class UnionIF : public ImplicitFunction<T>
{
public:
  UnionIF() = delete;
 
  UnionIF(const std::vector<std::shared_ptr<ImplicitFunction<T>>>& a_implicitFunctions) noexcept;
 
  virtual ~UnionIF() = default;
 
  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:
  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>) noexcept;
 
  virtual ~SmoothUnionIF() = default;
 
  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 FastUnionIF : public ImplicitFunction<T>
{
public:
  static_assert(std::is_base_of<EBGeometry::ImplicitFunction<T>, P>::value,
                "FastUnionIF requires an implicit function");
 
  using Root = typename EBGeometry::BVH::LinearBVH<T, P, BV, K>;
 
  using Node = typename Root::LinearNode;
 
  FastUnionIF() = delete;
 
  FastUnionIF(const std::vector<std::pair<std::shared_ptr<const P>, BV>>& a_primsAndBVs) noexcept;
 
  FastUnionIF(const std::vector<std::shared_ptr<P>>& a_primitives, const std::vector<BV>& a_boundingVolumes) noexcept;
 
  virtual ~FastUnionIF() = default;
 
  virtual T
  value(const Vec3T<T>& a_point) const noexcept override;
 
  const BV&
  getBoundingVolume() const noexcept;
 
protected:
  std::shared_ptr<EBGeometry::BVH::LinearBVH<T, P, BV, 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::TopDown) noexcept;
};
 
template <class T, class P, class BV, size_t K>
class FastSmoothUnionIF : public FastUnionIF<T, P, BV, K>
{
public:
  static_assert(std::is_base_of<EBGeometry::ImplicitFunction<T>, P>::value,
                "FastSmoothUnionIF requires an implicit function");
 
  using Root = typename EBGeometry::BVH::LinearBVH<T, P, BV, K>;
 
  using Node = typename Root::LinearNode;
 
  FastSmoothUnionIF() = delete;
 
  FastSmoothUnionIF(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;
 
  virtual ~FastSmoothUnionIF() = default;
 
  virtual T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  T m_smoothLen;
 
  std::function<T(const T&, const T&, const T&)> m_smoothMin;
};
 
template <class T>
class IntersectionIF : public ImplicitFunction<T>
{
public:
  IntersectionIF() = delete;
 
  IntersectionIF(const std::vector<std::shared_ptr<ImplicitFunction<T>>>& a_implicitFunctions) noexcept;
 
  virtual ~IntersectionIF() = default;
 
  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:
  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;
 
  virtual ~SmoothIntersectionIF() = default;
 
  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:
  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;
 
  virtual ~DifferenceIF() = default;
 
  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:
  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;
 
  virtual ~SmoothDifferenceIF() = default;
 
  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:
  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;
 
  virtual ~FiniteRepetitionIF() = default;
 
  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;
};
 
#include "EBGeometry_NamespaceFooter.hpp"
 
#include "EBGeometry_CSGImplem.hpp"
 
#endif