EBGeometry_Transform.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_TRANSFORM_HPP
#define EBGEOMETRY_TRANSFORM_HPP
 
// Std includes
#include <cstddef>
#include <memory>
#include <type_traits>
#include <utility>
#include <vector>
 
// Our includes
#include "EBGeometry_ImplicitFunction.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
template <class T>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Complement(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction);
 
template <class T>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Translate(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const Vec3T<T>& a_shift);
 
template <class T>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Rotate(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_angle, const size_t a_axis);
 
template <class T>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Scale(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_scale);
 
template <class T>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Offset(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_offset);
 
template <class T>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Annular(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_delta);
 
template <class T>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Blur(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_blurDistance);
 
template <class T>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Mollify(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction,
        const T                                     a_dist,
        const size_t                                a_mollifierSamples = 2);
 
template <class T>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Elongate(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const Vec3T<T>& a_elongation);
 
template <class T>
[[nodiscard]] std::shared_ptr<ImplicitFunction<T>>
Reflect(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const size_t& a_reflectPlane);
 
template <class T>
class ComplementIF : public ImplicitFunction<T>
{
  static_assert(std::is_floating_point_v<T>, "ComplementIF requires a floating-point T");
 
public:
  ComplementIF() = delete;
 
  ComplementIF(const ComplementIF& a_other) noexcept = default;
 
  ComplementIF(ComplementIF&& a_other) noexcept = default;
 
  ComplementIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction) noexcept;
 
  ~ComplementIF() override = default;
 
  ComplementIF&
  operator=(const ComplementIF& a_other) noexcept = default;
 
  ComplementIF&
  operator=(ComplementIF&& a_other) noexcept = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction = nullptr;
};
 
template <class T>
class TranslateIF : public ImplicitFunction<T>
{
  static_assert(std::is_floating_point_v<T>, "TranslateIF requires a floating-point T");
 
public:
  TranslateIF() = delete;
 
  TranslateIF(const TranslateIF& a_other) noexcept = default;
 
  TranslateIF(TranslateIF&& a_other) noexcept = default;
 
  TranslateIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const Vec3T<T>& a_shift) noexcept;
 
  ~TranslateIF() override = default;
 
  TranslateIF&
  operator=(const TranslateIF& a_other) noexcept = default;
 
  TranslateIF&
  operator=(TranslateIF&& a_other) noexcept = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction = nullptr;
 
  Vec3T<T> m_shift;
};
 
template <class T>
class RotateIF : public ImplicitFunction<T>
{
  static_assert(std::is_floating_point_v<T>, "RotateIF requires a floating-point T");
 
public:
  RotateIF() = delete;
 
  RotateIF(const RotateIF& a_other) noexcept = default;
 
  RotateIF(RotateIF&& a_other) noexcept = default;
 
  RotateIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction,
           const T                                     a_angle,
           const size_t                                a_axis) noexcept;
 
  ~RotateIF() override = default;
 
  RotateIF&
  operator=(const RotateIF& a_other) noexcept = default;
 
  RotateIF&
  operator=(RotateIF&& a_other) noexcept = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction = nullptr;
 
  size_t m_axis;
 
  T m_angle;
 
  T m_cosAngle;
 
  T m_sinAngle;
};
 
template <class T>
class OffsetIF : public ImplicitFunction<T>
{
  static_assert(std::is_floating_point_v<T>, "OffsetIF requires a floating-point T");
 
public:
  OffsetIF() = delete;
 
  OffsetIF(const OffsetIF& a_other) noexcept = default;
 
  OffsetIF(OffsetIF&& a_other) noexcept = default;
 
  OffsetIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_offset) noexcept;
 
  ~OffsetIF() override = default;
 
  OffsetIF&
  operator=(const OffsetIF& a_other) noexcept = default;
 
  OffsetIF&
  operator=(OffsetIF&& a_other) noexcept = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction = nullptr;
 
  T m_offset;
};
 
template <class T>
class ScaleIF : public ImplicitFunction<T>
{
  static_assert(std::is_floating_point_v<T>, "ScaleIF requires a floating-point T");
 
public:
  ScaleIF() = delete;
 
  ScaleIF(const ScaleIF& a_other) noexcept = default;
 
  ScaleIF(ScaleIF&& a_other) noexcept = default;
 
  ScaleIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_scale) noexcept;
 
  ~ScaleIF() override = default;
 
  ScaleIF&
  operator=(const ScaleIF& a_other) noexcept = default;
 
  ScaleIF&
  operator=(ScaleIF&& a_other) noexcept = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction = nullptr;
 
  T m_scale;
};
 
template <class T>
class AnnularIF : public ImplicitFunction<T>
{
  static_assert(std::is_floating_point_v<T>, "AnnularIF requires a floating-point T");
 
public:
  AnnularIF() = delete;
 
  AnnularIF(const AnnularIF& a_other) noexcept = default;
 
  AnnularIF(AnnularIF&& a_other) noexcept = default;
 
  AnnularIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const T a_delta) noexcept;
 
  ~AnnularIF() override = default;
 
  AnnularIF&
  operator=(const AnnularIF& a_other) noexcept = default;
 
  AnnularIF&
  operator=(AnnularIF&& a_other) noexcept = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<const ImplicitFunction<T>> m_implicitFunction = nullptr;
 
  T m_delta;
};
 
template <class T>
class BlurIF : public ImplicitFunction<T>
{
  static_assert(std::is_floating_point_v<T>, "BlurIF requires a floating-point T");
 
public:
  BlurIF() = delete;
 
  BlurIF(const BlurIF& a_other) noexcept = default;
 
  BlurIF(BlurIF&& a_other) noexcept = default;
 
  BlurIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction,
         const T                                     a_blurDistance,
         const T                                     a_alpha = 0.5) noexcept;
 
  ~BlurIF() override = default;
 
  BlurIF&
  operator=(const BlurIF& a_other) noexcept = default;
 
  BlurIF&
  operator=(BlurIF&& a_other) noexcept = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction = nullptr;
 
  T m_blurDistance;
 
  T m_alpha;
};
 
template <class T>
class MollifyIF : public ImplicitFunction<T>
{
  static_assert(std::is_floating_point_v<T>, "MollifyIF requires a floating-point T");
 
public:
  MollifyIF() = delete;
 
  MollifyIF(const MollifyIF& a_other) = default;
 
  MollifyIF(MollifyIF&& a_other) noexcept = default;
 
  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;
 
  ~MollifyIF() override = default;
 
  MollifyIF&
  operator=(const MollifyIF& a_other) = default;
 
  MollifyIF&
  operator=(MollifyIF&& a_other) noexcept = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<ImplicitFunction<T>> m_implicitFunction = nullptr;
 
  std::shared_ptr<ImplicitFunction<T>> m_mollifier = nullptr;
 
  std::vector<std::pair<Vec3T<T>, T>> m_sampledMollifier;
};
 
template <class T>
class ElongateIF : public ImplicitFunction<T>
{
  static_assert(std::is_floating_point_v<T>, "ElongateIF requires a floating-point T");
 
public:
  ElongateIF() = delete;
 
  ElongateIF(const ElongateIF& a_other) noexcept = default;
 
  ElongateIF(ElongateIF&& a_other) noexcept = default;
 
  ElongateIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const Vec3T<T>& a_elongation) noexcept;
 
  ~ElongateIF() override = default;
 
  ElongateIF&
  operator=(const ElongateIF& a_other) noexcept = default;
 
  ElongateIF&
  operator=(ElongateIF&& a_other) noexcept = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<const ImplicitFunction<T>> m_implicitFunction = nullptr;
 
  Vec3T<T> m_elongation;
};
 
template <class T>
class ReflectIF : public ImplicitFunction<T>
{
  static_assert(std::is_floating_point_v<T>, "ReflectIF requires a floating-point T");
 
public:
  ReflectIF() = delete;
 
  ReflectIF(const ReflectIF& a_other) noexcept = default;
 
  ReflectIF(ReflectIF&& a_other) noexcept = default;
 
  ReflectIF(const std::shared_ptr<ImplicitFunction<T>>& a_implicitFunction, const size_t& a_reflectPlane) noexcept;
 
  ~ReflectIF() override = default;
 
  ReflectIF&
  operator=(const ReflectIF& a_other) noexcept = default;
 
  ReflectIF&
  operator=(ReflectIF&& a_other) noexcept = default;
 
  [[nodiscard]] T
  value(const Vec3T<T>& a_point) const noexcept override;
 
protected:
  std::shared_ptr<const ImplicitFunction<T>> m_implicitFunction = nullptr;
 
  Vec3T<T> m_reflectParams;
};
 
} // namespace EBGeometry
 
#include "EBGeometry_TransformImplem.hpp"
 
#endif