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 "../Common/Assert.h"
#include "./defines.h"
#include PONCA_MULTIARCH_INCLUDE_CU_STD(utility)
 
namespace Ponca
{
    namespace internal
    {
        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 const 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;
            }
        };
    } // namespace internal
 
    template <class DataPoint, class WeightKernel>
    class DistWeightFunc : public internal::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 = internal::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)
        {
            PONCA_ASSERT(_t > Scalar(0));
        }
 
        PONCA_MULTIARCH inline DistWeightFunc(const DataPoint& _evalPoint, const Scalar& _t = Scalar(1.))
            : NeighborhoodFrame(_evalPoint.pos()), m_t(_t)
        {
            PONCA_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
 
    namespace internal
    {
        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
    } // namespace internal
 
    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(1.),
                                                         const VectorType& _evalNormal = VectorType::Zero())
            : Base(_evalPos, _t), m_n(_evalNormal)
        {
        }
 
        PONCA_MULTIARCH inline NeighborFilterStoreNormal(const DataPoint& _evalPoint, const Scalar& _t = Scalar(1.))
            : 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>
    struct NoWeightFunc : public internal::NoWeightFuncBase<DataPoint, internal::CenteredNeighborhoodFrame>
    {
        using internal::NoWeightFuncBase<DataPoint, internal::CenteredNeighborhoodFrame>::NoWeightFuncBase;
    };
 
    template <class DataPoint>
    struct NoWeightFuncGlobal : public internal::NoWeightFuncBase<DataPoint, internal::GlobalNeighborhoodFrame>
    {
        using internal::NoWeightFuncBase<DataPoint, internal::GlobalNeighborhoodFrame>::NoWeightFuncBase;
    };
 
#include "weightFunc.hpp"
 
} // namespace Ponca