weightFilter.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 "./frame.h"
#include PONCA_MULTIARCH_INCLUDE_CU_STD(utility)
 
namespace Ponca
{
    template <class _DataPoint, class WeightKernel>
    class DistWeightFilter : public CenteredNeighborhoodFrame<_DataPoint>
    {
    public:
        using DataPoint = _DataPoint;
        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 DistWeightFilter(const VectorType& _evalPos = VectorType::Zero(),
                                                const Scalar& _t           = Scalar(1.))
            : NeighborhoodFrame(_evalPos), m_t(_t)
        {
            PONCA_ASSERT(_t > Scalar(0));
        }
 
        PONCA_MULTIARCH inline DistWeightFilter(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; }
 
        PONCA_MULTIARCH [[nodiscard]] inline NeighborhoodFrame& frame() { return *this; }
        PONCA_MULTIARCH [[nodiscard]] inline const NeighborhoodFrame& frame() const { return *this; }
 
    protected:
        Scalar m_t;        
        WeightKernel m_wk; 
    }; // class DistWeightFunc
 
    namespace internal
    {
        template <class _DataPoint, template <typename> typename _NeighborhoodFrame>
        class NoWeightFilterBase : public _NeighborhoodFrame<_DataPoint>
        {
        public:
            using DataPoint = _DataPoint;
            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 NoWeightFilterBase(const VectorType& v = VectorType::Zero(), Scalar = 0)
                : NeighborhoodFrame(v)
            {
            }
 
            PONCA_MULTIARCH inline NoWeightFilterBase(const DataPoint& v, Scalar = 0) : NoWeightFilterBase(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();
            }
 
            PONCA_MULTIARCH [[nodiscard]] inline NeighborhoodFrame& frame() { return *this; }
            PONCA_MULTIARCH [[nodiscard]] inline const NeighborhoodFrame& frame() const { return *this; }
        }; // class NoWeightFuncBase
 
        template <typename DataPoint>
        inline constexpr typename DataPoint::VectorType ConvertDataPointToNormal(const DataPoint& pt)
        {
            return pt.normal();
        }
    } // namespace internal
 
    template <class _DataPoint, typename DataType, typename NeighborFilter, auto DataConverter>
    class FilterWithAttributes : public NeighborFilter
    {
    public:
        using DataPoint = _DataPoint;
        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 FilterWithAttributes(const VectorType& _evalPos = VectorType::Zero(),
                                                    const Scalar& _t = Scalar(1), const DataType& _data = DataType{})
            : Base(_evalPos, _t), m_data(_data)
        {
        }
 
        PONCA_MULTIARCH inline FilterWithAttributes(const DataPoint& _evalPoint, const Scalar& _t = Scalar(0))
            : Base(_evalPoint.pos(), _t), m_data(DataConverter(_evalPoint))
        {
        }
 
        PONCA_MULTIARCH inline const DataType& data() const { return m_data; }
 
    protected:
        DataType m_data; 
    }; // class FilterWithAttributes
 
    template <class DataPoint>
    struct NoWeightFilter : public internal::NoWeightFilterBase<DataPoint, CenteredNeighborhoodFrame>
    {
        using internal::NoWeightFilterBase<DataPoint, CenteredNeighborhoodFrame>::NoWeightFilterBase;
    };
 
    template <class DataPoint>
    struct NoWeightFilterGlobal : public internal::NoWeightFilterBase<DataPoint, GlobalNeighborhoodFrame>
    {
        using internal::NoWeightFilterBase<DataPoint, GlobalNeighborhoodFrame>::NoWeightFilterBase;
    };
 
#include "weightFilter.hpp"
 
} // namespace Ponca