EBGeometry_Transform.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_Transform
#define EBGeometry_Transform
 
// Our includes
#include "EBGeometry_ImplicitFunction.hpp"
#include "EBGeometry_Vec.hpp"
#include "EBGeometry_NamespaceHeader.hpp"
 
template <class T>
std::shared_ptr<ImplicitFunction<T>>
Complement(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction) noexcept;
 
template <class T>
std::shared_ptr<ImplicitFunction<T>>
Translate(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const Vec3T<T>& a_shift) noexcept;
 
template <class T>
std::shared_ptr<ImplicitFunction<T>>
Rotate(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_angle, const size_t a_axis) noexcept;
 
template <class T>
std::shared_ptr<ImplicitFunction<T>>
Scale(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_scale) noexcept;
 
template <class T>
std::shared_ptr<ImplicitFunction<T>>
Offset(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_offset) noexcept;
 
template <class T>
std::shared_ptr<ImplicitFunction<T>>
Annular(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_delta) noexcept;
 
template <class T>
std::shared_ptr<ImplicitFunction<T>>
Blur(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_blurDistance) noexcept;
 
template <class T>
std::shared_ptr<ImplicitFunction<T>>
Mollify(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction,
        const T                                     a_dist,
        const size_t                                a_mollifierSamples = 2) noexcept;
 
template <class T>
std::shared_ptr<ImplicitFunction<T>>
Elongate(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const Vec3T<T>& a_elongation) noexcept;
 
template <class T>
std::shared_ptr<ImplicitFunction<T>>
Reflect(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const size_t& a_reflectPlane) noexcept;
 
template <class T>
class ComplementIF : public ImplicitFunction<T>
{
public:
  ComplementIF() = delete;
 
  ComplementIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction) noexcept;
 
  virtual ~ComplementIF();
 
  virtual T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction;
};
 
template <class T>
class TranslateIF : public ImplicitFunction<T>
{
public:
  TranslateIF() = delete;
 
  TranslateIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const Vec3T<T>& a_shift) noexcept;
 
  virtual ~TranslateIF();
 
  virtual T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction;
 
  Vec3T<T> m_shift;
};
 
template <class T>
class RotateIF : public ImplicitFunction<T>
{
public:
  RotateIF() = delete;
 
  RotateIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction,
           const T                                     a_angle,
           const size_t                                a_axis) noexcept;
 
  virtual ~RotateIF();
 
  virtual T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction;
 
  size_t m_axis;
 
  T m_angle;
 
  T m_cosAngle;
 
  T m_sinAngle;
};
 
template <class T>
class OffsetIF : public ImplicitFunction<T>
{
public:
  OffsetIF() = delete;
 
  OffsetIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_offset) noexcept;
 
  virtual ~OffsetIF();
 
  virtual T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction;
 
  T m_offset;
};
 
template <class T>
class ScaleIF : public ImplicitFunction<T>
{
public:
  ScaleIF() = delete;
 
  ScaleIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_scale) noexcept;
 
  virtual ~ScaleIF() noexcept;
 
  virtual T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction;
 
  T m_scale;
};
 
template <class T>
class AnnularIF : public ImplicitFunction<T>
{
public:
  AnnularIF() = delete;
 
  AnnularIF(const std::shared_ptr<ImplicitFunction<T>> a_implicitFunction, const T a_delta);
 
  virtual ~AnnularIF();
 
  virtual T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<const ImplicitFunction<T>> m_implicitFunction;
 
  T m_delta;
};
 
template <class T>
class BlurIF : public ImplicitFunction<T>
{
public:
  BlurIF() = delete;
 
  BlurIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction,
         const T                                     a_blurDistance,
         const T                                     a_alpha = 0.5) noexcept;
 
  virtual ~BlurIF() noexcept;
 
  virtual T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction;
 
  T m_blurDistance;
 
  T m_alpha;
};
 
template <class T>
class MollifyIF : public ImplicitFunction<T>
{
public:
  MollifyIF() = delete;
 
  MollifyIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction,
            const std::shared_ptr<ImplicitFunction<T>>& a_mollifier,
            const T                                     a_maxValue,
            const size_t                                a_numPoints) noexcept;
 
  virtual ~MollifyIF() noexcept;
 
  virtual T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction;
 
  std::shared_ptr<ImplicitFunction<T>> m_mollifier;
 
  std::vector<std::pair<Vec3T<T>, T>> m_sampledMollifier;
};
 
template <class T>
class ElongateIF : public ImplicitFunction<T>
{
public:
  ElongateIF() = delete;
 
  ElongateIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const Vec3T<T>& a_elongation) noexcept;
 
  virtual ~ElongateIF() noexcept;
 
  virtual T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<const ImplicitFunction<T>> m_implicitFunction;
 
  Vec3T<T> m_elongation;
};
 
template <class T>
class ReflectIF : public ImplicitFunction<T>
{
public:
  ReflectIF() = delete;
 
  ReflectIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const size_t& a_reflectPlane) noexcept;
 
  virtual ~ReflectIF() noexcept;
 
  virtual T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<const ImplicitFunction<T>> m_implicitFunction;
 
  Vec3T<T> m_reflectParams;
};
 
#include "EBGeometry_NamespaceFooter.hpp"
 
#include "EBGeometry_TransformImplem.hpp"
 
#endif