primitive_funcs_lib.hpp

Go to the documentation of this file.

// --------------------------------------------------------------------------
//
// Copyright (C) 2025-present by Pablo Antolin
//
// This file is part of the QUGaR library.
//
// SPDX-License-Identifier:    MIT
//
// --------------------------------------------------------------------------
 
#ifndef QUGAR_IMPL_PRIMITIVE_FUNCS_LIB_HPP
#define QUGAR_IMPL_PRIMITIVE_FUNCS_LIB_HPP
 
 
#include <qugar/bezier_tp.hpp>
#include <qugar/domain_function.hpp>
#include <qugar/impl_funcs_lib_macros.hpp>
#include <qugar/monomials_tp.hpp>
#include <qugar/numbers.hpp>
#include <qugar/point.hpp>
#include <qugar/ref_system.hpp>
#include <qugar/types.hpp>
 
#include <memory>
 
namespace qugar::impl::funcs {
 
template<int dim> class SphereBase
{
public:
  SphereBase(real radius, const Point<dim> &center);
 
  [[nodiscard]] real radius() const;
 
  [[nodiscard]] const Point<dim> &center() const;
 
protected:
  [[nodiscard]] static Point<dim> get_default_center();
 
  real radius_{ 0 };
 
  Point<dim> center_;
};
 
 
template<int dim>
class Sphere
  : public SphereBase<dim>
  , public ImplicitFunc<dim>
{
public:
  explicit Sphere(real radius);
 
  Sphere(real radius, const Point<dim> &center);
 
  declare_impl_func_virtual_interface;
};
 
 
template<int dim>
class SphereBzr
  : public SphereBase<dim>
  , public BezierTP<dim, 1>
{
public:
  explicit SphereBzr(real radius);
 
  SphereBzr(real radius, const Point<dim> &center);
 
private:
  [[nodiscard]] static std::shared_ptr<MonomialsTP<dim, 1>> create_monomials(real radius, const Point<dim> &center);
};
 
class CylinderBase
{
public:
  CylinderBase(real radius, const Point<3> &origin, const Point<3> &axis);
 
 
  [[nodiscard]] real radius() const;
 
  [[nodiscard]] const Point<3> &origin() const;
 
  [[nodiscard]] const Point<3> &axis() const;
 
protected:
  [[nodiscard]] static Point<3> get_default_origin();
 
  [[nodiscard]] static Point<3> get_default_axis();
 
  real radius_;
 
  Point<3> origin_;
 
  Point<3> axis_;
};
 
class CylinderBzr
  : public CylinderBase
  , public BezierTP<3, 1>
{
public:
  explicit CylinderBzr(real radius);
 
  CylinderBzr(real radius, const Point<3> &origin);
 
  CylinderBzr(real radius, const Point<3> &origin, const Point<3> &axis);
 
  [[nodiscard]] static std::shared_ptr<MonomialsTP<3, 1>>
    create_monomials(real radius, const Point<3> &origin, const Point<3> &axis);
};
 
 
class Cylinder
  : public CylinderBase
  , public ImplicitFunc<3>
{
public:
  static const int dim = 3;
 
  explicit Cylinder(real radius);
 
  Cylinder(real radius, const Point<3> &origin);
 
  Cylinder(real radius, const Point<3> &origin, const Point<3> &axis);
 
  declare_impl_func_virtual_interface;
};
 
template<int dim> class EllipsoidBase
{
public:
  EllipsoidBase(const Point<dim> &semi_axes, const RefSystem<dim> &system);
 
  [[nodiscard]] const Point<dim> &semi_axes() const;
 
  [[nodiscard]] const RefSystem<dim> &ref_system() const;
 
protected:
  Point<dim> semi_axes_;
 
  RefSystem<dim> system_;
 
  [[nodiscard]] static RefSystem<dim> get_default_system();
};
 
template<int dim>
class EllipsoidBzr
  : public EllipsoidBase<dim>
  , public BezierTP<dim, 1>
{
public:
  explicit EllipsoidBzr(const Point<dim> &semi_axes);
 
  EllipsoidBzr(const Point<dim> &semi_axes, const RefSystem<dim> &system);
 
private:
  [[nodiscard]] static std::shared_ptr<MonomialsTP<dim, 1>> create_monomials(const Point<dim> &semi_axes,
    const RefSystem<dim> &system);
};
 
template<int dim>
class Ellipsoid
  : public EllipsoidBase<dim>
  , public ImplicitFunc<dim>
{
public:
  explicit Ellipsoid(const Point<dim> &semi_axes);
 
  Ellipsoid(const Point<dim> &semi_axes, const RefSystem<dim> &system);
 
  declare_impl_func_virtual_interface;
};
 
class AnnulusBase
{
public:
  AnnulusBase(real inner_radius, real outer_radius, const Point<2> &center);
 
  [[nodiscard]] const Point<2> &center() const;
 
  [[nodiscard]] real inner_radius() const;
 
  [[nodiscard]] real outer_radius() const;
 
protected:
  real inner_radius_;
 
  real outer_radius_;
 
  Point<2> center_;
 
  [[nodiscard]] static Point<2> get_default_center();
};
 
class AnnulusBzr
  : public AnnulusBase
  , public BezierTP<2, 1>
{
public:
  AnnulusBzr(real inner_radius, real outer_radius);
 
  AnnulusBzr(real inner_radius, real outer_radius, const Point<2> &center);
 
private:
  [[nodiscard]] static std::shared_ptr<MonomialsTP<2, 1>>
    create_monomials(real inner_radius, real outer_radius, const Point<2> &center);
};
 
 
class Annulus
  : public AnnulusBase
  , public ImplicitFunc<2>
{
public:
  Annulus(real inner_radius, real outer_radius);
 
  Annulus(real inner_radius, real outer_radius, const Point<2> &center);
 
  declare_impl_func_virtual_interface_2D;
};
 
class TorusBase
{
public:
  TorusBase(real major_radius, real minor_radius, const Point<3> &center, const Point<3> &axis);
 
  [[nodiscard]] real major_radius() const;
 
  [[nodiscard]] real minor_radius() const;
 
  [[nodiscard]] const Point<3> &center() const;
 
  [[nodiscard]] const Point<3> &axis() const;
 
protected:
  real major_radius_;
 
  real minor_radius_;
 
  Point<3> center_;
 
  Point<3> axis_;
 
  [[nodiscard]] static Point<3> get_default_center();
 
  [[nodiscard]] static Point<3> get_default_axis();
};
 
 
class TorusBzr
  : public TorusBase
  , public BezierTP<3, 1>
{
public:
  TorusBzr(real major_radius, real minor_radius);
 
  TorusBzr(real major_radius, real minor_radius, const Point<3> &center);
 
 
  TorusBzr(real major_radius, real minor_radius, const Point<3> &center, const Point<3> &axis);
 
private:
  [[nodiscard]] static std::shared_ptr<MonomialsTP<3, 1>>
    create_monomials(real major_radius, real minor_radius, const Point<3> &center, const Point<3> &axis);
};
 
class Torus
  : public TorusBase
  , public ImplicitFunc<3>
{
public:
  Torus(real major_radius, real minor_radius);
 
  Torus(real major_radius, real minor_radius, const Point<3> &center);
 
 
  Torus(real major_radius, real minor_radius, const Point<3> &center, const Point<3> &axis);
 
  declare_impl_func_virtual_interface_3D;
 
  template<typename T> Point<3, T> compute_P_x_0(const Point<3, T> &point) const;
};
 
class ConstantBase
{
public:
  static constexpr real default_value = numbers::half;
 
  explicit ConstantBase(real value);
 
  [[nodiscard]] real value() const;
 
protected:
  real value_{ 0.0 };
};
 
template<int dim>
class ConstantBzr
  : public ConstantBase
  , public BezierTP<dim, 1>
{
public:
  ConstantBzr();
 
  explicit ConstantBzr(real value);
};
 
template<int dim>
class Constant
  : public ConstantBase
  , public ImplicitFunc<dim>
{
public:
  Constant();
 
  explicit Constant(real value);
 
  declare_impl_func_virtual_interface;
};
 
template<int dim> class PlaneBase
{
public:
  PlaneBase(const Point<dim> &origin, const Point<dim> &normal);
 
  [[nodiscard]] const Point<dim> &origin() const;
 
  [[nodiscard]] const Point<dim> &normal() const;
 
protected:
  Point<dim> origin_;
 
  Point<dim> normal_;
 
  [[nodiscard]] static Point<dim> get_default_origin();
 
  [[nodiscard]] static Point<dim> get_default_normal();
};
 
template<int dim>
class PlaneBzr
  : public PlaneBase<dim>
  , public BezierTP<dim, 1>
{
public:
  PlaneBzr();
 
  PlaneBzr(const Point<dim> &origin, const Point<dim> &normal);
 
private:
  [[nodiscard]] static std::shared_ptr<MonomialsTP<dim, 1>> create_monomials(const Point<dim> &origin,
    const Point<dim> &normal);
};
 
template<int dim>
class Plane
  : public PlaneBase<dim>
  , public ImplicitFunc<dim>
{
public:
  Plane();
 
  Plane(const Point<dim> &origin, const Point<dim> &normal);
 
  declare_impl_func_virtual_interface;
};
 
 
}// namespace qugar::impl::funcs
 
 
#endif// QUGAR_IMPL_PRIMITIVE_FUNCS_LIB_HPP