UnaryNode.h

Go to the documentation of this file.

 
#ifndef PBAT_GEOMETRY_SDF_UNARYNODE_H
#define PBAT_GEOMETRY_SDF_UNARYNODE_H
 
#include "TypeDefs.h"
#include "pbat/HostDevice.h"
#include "pbat/common/Concepts.h"
#include "pbat/math/linalg/mini/BinaryOperations.h"
#include "pbat/math/linalg/mini/UnaryOperations.h"
 
#include <algorithm>
#include <cmath>
#include <numbers>
 
namespace pbat::geometry::sdf {

struct UnaryNode
{
};

template <common::CArithmetic TScalar>
struct Scale : public UnaryNode
{
    using ScalarType = TScalar; 
    ScalarType s{TScalar(1)};   
    Scale() = default;
    explicit Scale(ScalarType s_) : s(s_) {}
    template <class FSdf>
    PBAT_HOST_DEVICE ScalarType Eval(Vec3<ScalarType> const& p, FSdf&& sdf) const
    {
        return s * sdf(Vec3<ScalarType>(p / s));
    }
};

template <common::CArithmetic TScalar>
struct Elongate : public UnaryNode
{
    using ScalarType = TScalar;                             
    Vec3<ScalarType> h{TScalar(1), TScalar(1), TScalar(1)}; 
    Elongate() = default;
    explicit Elongate(Vec3<ScalarType> const& h_) : h(h_) {}
    template <class FSdf>
    PBAT_HOST_DEVICE ScalarType Eval(Vec3<ScalarType> const& p, FSdf&& sdf) const
    {
        Vec3<ScalarType> q  = Abs(p) - h;
        Vec3<ScalarType> pp = Max(q, Zero3<ScalarType>{});
        using namespace std;
        return sdf(pp) + min(max(q(0), max(q(1), q(2))), ScalarType(0));
    }
};

template <common::CArithmetic TScalar>
struct Round : public UnaryNode
{
    using ScalarType = TScalar;  
    ScalarType r{TScalar(0.01)}; 
    Round() = default;
    explicit Round(ScalarType r_) : r(r_) {}
    template <class FSdf>
    PBAT_HOST_DEVICE ScalarType Eval(Vec3<ScalarType> const& p, FSdf&& sdf) const
    {
        return sdf(p) - r;
    }
};

template <common::CArithmetic TScalar>
struct Onion : public UnaryNode
{
    using ScalarType = TScalar;  
    ScalarType t{TScalar(0.01)}; 
    Onion() = default;
    explicit Onion(ScalarType t_) : t(t_) {}
    template <class FSdf>
    PBAT_HOST_DEVICE ScalarType Eval(Vec3<ScalarType> const& p, FSdf&& sdf) const
    {
        using namespace std;
        return abs(sdf(p)) - t;
    }
};

template <common::CArithmetic TScalar>
struct Symmetrize : public UnaryNode
{
    using ScalarType = TScalar; 
    template <class FSdf>
    PBAT_HOST_DEVICE ScalarType Eval(Vec3<ScalarType> p, FSdf&& sdf) const
    {
        using namespace std;
        p(0) = abs(p(0));
        p(2) = abs(p(2));
        return sdf(p);
    }
};

template <common::CArithmetic TScalar>
struct Repeat : public UnaryNode
{
    using ScalarType = TScalar; 
    ScalarType s{TScalar(1)};   
    Vec3<ScalarType> l{
        TScalar(5),
        TScalar(5),
        TScalar(5)}; 

    Repeat() = default;
    explicit Repeat(ScalarType s_, Vec3<ScalarType> const& l_) : s(s_), l(l_) {}
    template <class FSdf>
    PBAT_HOST_DEVICE ScalarType Eval(Vec3<ScalarType> const& p, FSdf&& sdf) const
    {
        using namespace std;
        Vec3<ScalarType> pc{
            clamp(round(p(0) / s), -l(0), l(0)),
            clamp(round(p(1) / s), -l(1), l(1)),
            clamp(round(p(2) / s), -l(2), l(2))};
        Vec3<ScalarType> q = p - s * pc;
        return sdf(q);
    }
};

template <common::CArithmetic TScalar>
struct RotationalRepeat : public UnaryNode
{
    using ScalarType = TScalar; 
    ScalarType n{TScalar(1)};   
    RotationalRepeat() = default;
    explicit RotationalRepeat(ScalarType n_) : n(n_) {}
    template <class FSdf>
    PBAT_HOST_DEVICE ScalarType Eval(Vec3<ScalarType> const& p, FSdf&& sdf) const
    {
        using namespace std;
        ScalarType sp    = 2 * std::numbers::pi_v<ScalarType> / n;
        ScalarType an    = atan2(p(1), p(0));
        ScalarType id    = floor(an / sp);
        ScalarType a1    = sp * (id);
        ScalarType a2    = sp * (id + 1);
        ScalarType cosa1 = cos(a1);
        ScalarType sina1 = sin(a1);
        ScalarType cosa2 = cos(a2);
        ScalarType sina2 = sin(a2);
        Vec3<ScalarType> r1{cosa1 * p(0) + sina1 * p(1), -sina1 * p(0) + cosa1 * p(1), p(2)};
        Vec3<ScalarType> r2{cosa2 * p(0) + sina2 * p(1), -sina2 * p(0) + cosa2 * p(1), p(2)};
        return min(sdf(r1), sdf(r2));
    }
};

template <common::CArithmetic TScalar>
struct Bump : public UnaryNode
{
    using ScalarType = TScalar;                             
    Vec3<ScalarType> f{TScalar(1), TScalar(1), TScalar(1)}; 
    Vec3<ScalarType> g{TScalar(1), TScalar(1), TScalar(1)}; 
    Bump() = default;
    explicit Bump(Vec3<ScalarType> const& f_, Vec3<ScalarType> const& g_) : f(f_), g(g_) {}
    template <class FSdf>
    PBAT_HOST_DEVICE ScalarType Eval(Vec3<ScalarType> const& p, FSdf&& sdf) const
    {
        using namespace std;
        // clang-format off
        ScalarType d = 
            g(0)*sin(f(0)*p(0)) * 
            g(1)*sin(f(1)*p(1)) * 
            g(2)*sin(f(2)*p(2));
        // clang-format on
        return sdf(p) + d;
    }
};

template <common::CArithmetic TScalar>
struct Twist : public UnaryNode
{
    using ScalarType = TScalar; 
    ScalarType k{0.2};          
    Twist() = default;
    explicit Twist(ScalarType k_) : k(k_) {}
    template <class FSdf>
    PBAT_HOST_DEVICE ScalarType Eval(Vec3<ScalarType> const& p, FSdf&& sdf) const
    {
        using namespace std;
        ScalarType c = cos(k * p(1));
        ScalarType s = sin(k * p(1));
        Vec3<ScalarType> q{c * p(0) - s * p(2), s * p(0) + c * p(2), p(1)};
        return sdf(q);
    }
};

template <common::CArithmetic TScalar>
struct Bend : public UnaryNode
{
    using ScalarType = TScalar; 
    ScalarType k{0.2};          
    Bend() = default;
    explicit Bend(ScalarType k_) : k(k_) {}
    template <class FSdf>
    PBAT_HOST_DEVICE ScalarType Eval(Vec3<ScalarType> const& p, FSdf&& sdf) const
    {
        using namespace std;
        ScalarType c = cos(k * p(0));
        ScalarType s = sin(k * p(0));
        Vec3<ScalarType> q{c * p(0) - s * p(1), s * p(0) + c * p(1), p(2)};
        return sdf(q);
    }
};
 
} // namespace pbat::geometry::sdf
 
#endif // PBAT_GEOMETRY_SDF_UNARYNODE_H