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