weightFunc.h

/*
 This Source Code Form is subject to the terms of the Mozilla Public
 License, v. 2.0. If a copy of the MPL was not distributed with this
 file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
 
#pragma once
 
#include "./defines.h"
#include PONCA_MULTIARCH_INCLUDE_CU_STD(utility)
 
namespace Ponca
{
template<class DataPoint>
class CenteredNeighborhoodFrame {
public:
    using Scalar =  typename DataPoint::Scalar;
    using VectorType =  typename DataPoint::VectorType;
 
    static constexpr bool hasLocalFrame = true;
 
    PONCA_MULTIARCH inline explicit CenteredNeighborhoodFrame(const VectorType & _evalPos = VectorType::Zero())
    : m_p(_evalPos) {}
 
    PONCA_MULTIARCH inline explicit CenteredNeighborhoodFrame(const DataPoint & _evalPoint)
    : m_p(_evalPoint.pos()) {}
 
    PONCA_MULTIARCH inline void changeNeighborhoodFrame(const VectorType& _newEvalPos) { m_p = _newEvalPos; };
 
    PONCA_MULTIARCH [[nodiscard]] inline VectorType convertToGlobalBasis(const VectorType& _q,
                                                                         bool _isPositionVector = true) const {
        return ( _isPositionVector ? (_q + m_p) : _q );
    }
 
    PONCA_MULTIARCH [[nodiscard]] inline VectorType convertToLocalBasis(const VectorType& _q,
                                                                        bool _isPositionVector = true) const {
        return ( _isPositionVector ? (_q - m_p) : _q );
    }
 
    PONCA_MULTIARCH [[nodiscard]] inline VectorType evalPos() const { return m_p; }
 
private:
    VectorType m_p;  
};
template<class DataPoint>
class GlobalNeighborhoodFrame {
public:
    using Scalar =  typename DataPoint::Scalar;
    using VectorType =  typename DataPoint::VectorType;
 
    static constexpr bool hasLocalFrame = false;
 
    PONCA_MULTIARCH inline explicit GlobalNeighborhoodFrame(const VectorType & /*_evalPos*/ = VectorType::Zero()) {}
 
    PONCA_MULTIARCH inline void changeNeighborhoodFrame(const VectorType& /*_newEvalPos*/) {};
 
    PONCA_MULTIARCH [[nodiscard]] inline const VectorType& convertToGlobalBasis(const VectorType& _q,
                                                                                bool /*_isPositionVector*/ = true) const {
        return _q;
    }
 
    PONCA_MULTIARCH [[nodiscard]] inline const VectorType& convertToLocalBasis(const VectorType& _q,
                                                                               bool /*_isPositionVector*/ = true) const {
        return _q;
    }
};
 
 
template <class DataPoint, class WeightKernel>
class DistWeightFunc : public CenteredNeighborhoodFrame<DataPoint>
{
public:
    using Scalar =  typename DataPoint::Scalar;
    using VectorType =  typename DataPoint::VectorType;
    using MatrixType = typename DataPoint::MatrixType;
    using WeightReturnType = PONCA_MULTIARCH_CU_STD_NAMESPACE(pair)<Scalar, VectorType>;
    using NeighborhoodFrame = CenteredNeighborhoodFrame<DataPoint>;
    static constexpr bool isCompact = WeightKernel::isCompact;
 
    PONCA_MULTIARCH inline DistWeightFunc(const VectorType & _evalPos = VectorType::Zero(),
                                              const Scalar& _t = Scalar(1.))
    : NeighborhoodFrame(_evalPos), m_t(_t)
    {
        //\todo manage that assert on __host__ and __device__
        //assert(_t > Scalar(0));
    }
 
    PONCA_MULTIARCH inline DistWeightFunc(const DataPoint & _evalPoint,
                                              const Scalar& _t = Scalar(1.))
    : NeighborhoodFrame(_evalPoint.pos()), m_t(_t)
    {
        //\todo manage that assert on __host__ and __device__
        //assert(_t > Scalar(0));
    }
 
    PONCA_MULTIARCH inline WeightReturnType operator()(const DataPoint& q) const;
 
 
    PONCA_MULTIARCH [[nodiscard]] inline VectorType spacedw(const VectorType& _q,
        const DataPoint&  /*attributes*/) const;
 
 
    PONCA_MULTIARCH [[nodiscard]] inline MatrixType spaced2w(const VectorType& _q,
        const DataPoint&  /*attributes*/) const;
 
    PONCA_MULTIARCH [[nodiscard]] inline Scalar scaledw(const VectorType& _q,
        const DataPoint&  /*attributes*/) const;
 
    PONCA_MULTIARCH [[nodiscard]] inline Scalar scaled2w(const VectorType& _q,
        const DataPoint&  /*attributes*/) const;
 
    PONCA_MULTIARCH [[nodiscard]] inline VectorType scaleSpaced2w(const VectorType& _q,
        const DataPoint&  /*attributes*/) const;
 
    PONCA_MULTIARCH [[nodiscard]] inline Scalar evalScale() const { return m_t; }
 
protected:
    Scalar       m_t;  
    WeightKernel m_wk; 
};// class DistWeightFunc
 
template <class DataPoint, template <typename>typename _NeighborhoodFrame>
class NoWeightFuncBase : public _NeighborhoodFrame<DataPoint>
{
public:
    using Scalar =  typename DataPoint::Scalar;
    using VectorType =  typename DataPoint::VectorType;
    using MatrixType = typename DataPoint::MatrixType;
    using WeightReturnType = PONCA_MULTIARCH_CU_STD_NAMESPACE(pair)<Scalar, VectorType>;
 
    using NeighborhoodFrame = _NeighborhoodFrame<DataPoint>;
 
    PONCA_MULTIARCH inline NoWeightFuncBase(const VectorType& v = VectorType::Zero(), Scalar = 0)
    : NeighborhoodFrame(v){ }
 
    PONCA_MULTIARCH inline NoWeightFuncBase(const DataPoint& v, Scalar = 0)
    : NeighborhoodFrame(v.pos()){ }
 
    PONCA_MULTIARCH inline WeightReturnType operator()(const DataPoint& _q) const
    {
        return {Scalar(1), NeighborhoodFrame::convertToLocalBasis(_q.pos())};
    }
 
 
    PONCA_MULTIARCH [[nodiscard]] inline VectorType spacedw(const VectorType& /*_q*/,
                                              const DataPoint&  /*attributes*/) const
    { return VectorType::Zeros(); }
 
 
    PONCA_MULTIARCH [[nodiscard]] inline MatrixType spaced2w(const VectorType& /*_q*/,
                                               const DataPoint&  /*attributes*/) const
    { return MatrixType::Zeros(); }
 
    PONCA_MULTIARCH [[nodiscard]] inline Scalar scaledw(const VectorType& /*_q*/,
                                          const DataPoint&  /*attributes*/) const
    { return Scalar(0); }
 
    PONCA_MULTIARCH [[nodiscard]] inline Scalar scaled2w(const VectorType& /*_q*/,
                                           const DataPoint&  /*attributes*/) const
    { return Scalar(0); }
 
    PONCA_MULTIARCH [[nodiscard]] inline VectorType scaleSpaced2w(const VectorType& /*_q*/,
                                                    const DataPoint&  /*attributes*/) const
    { return VectorType::Zeros(); }
};// class NoWeightFuncBase
 
template <class DataPoint, typename NeighborFilter>
class NeighborFilterStoreNormal : public NeighborFilter {
public:
    using Base       = NeighborFilter;
    using Scalar     =  typename DataPoint::Scalar;
    using VectorType =  typename DataPoint::VectorType;
    using MatrixType = typename DataPoint::MatrixType;
    using WeightReturnType = PONCA_MULTIARCH_CU_STD_NAMESPACE(pair)<Scalar, VectorType>;
 
    PONCA_MULTIARCH inline NeighborFilterStoreNormal(
        const VectorType & _evalPos = VectorType::Zero(),
        const Scalar& _t = Scalar(0),
        const VectorType & _evalNormal = VectorType::Zero())
    : Base(_evalPos, _t), m_n(_evalNormal) {}
 
    PONCA_MULTIARCH inline NeighborFilterStoreNormal(
        const DataPoint& _evalPoint,
        const Scalar& _t = Scalar(0))
    : Base(_evalPoint.pos(), _t), m_n(_evalPoint.normal()) {}
 
    PONCA_MULTIARCH inline const VectorType & evalNormal() const { return m_n; }
protected:
    VectorType   m_n;  
}; // class NeighborFilterStoreNormal
 
template <class DataPoint>
using NoWeightFunc = NoWeightFuncBase<DataPoint, CenteredNeighborhoodFrame>;
 
template <class DataPoint>
using NoWeightFuncGlobal = NoWeightFuncBase<DataPoint, GlobalNeighborhoodFrame>;
#include "weightFunc.hpp"
 
}// namespace Ponca