basket.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 "enums.h"
#include "primitive.h"
#include "compute.h"
 
#include PONCA_MULTIARCH_INCLUDE_STD(iterator)
 
namespace Ponca
{
 
#define BSKW typename BasketType::WeightFunction
#define BSKP typename BasketType::DataPoint
 
#ifndef PARSED_WITH_DOXYGEN
namespace internal
{
    template <class P, class W,
        typename Aggregate,
        template <class, class, typename> class Ext,
        template <class, class, typename> class... Exts>
    struct BasketAggregateImpl
    {
        using type = typename BasketAggregateImpl<P, W, Ext<P, W, Aggregate>, Exts...>::type;
    };
 
    template <class P, class W,
        typename Aggregate,
        template <class, class, typename> class Ext>
    struct BasketAggregateImpl<P, W, Aggregate, Ext>
    {
        using type = Ext<P, W, Aggregate>;
    };
 
    template <class P, class W,
        template <class, class, typename> class... Exts>
    struct BasketAggregate : BasketAggregateImpl<P, W, PrimitiveBase<P, W>, Exts...>
    {
    };
 
    template <int Type,
        typename BasketType,
        template <class, class, int, typename> class Ext,
        template <class, class, int, typename> class... Exts>
    struct BasketDiffAggregateImpl
    {
        using type = typename BasketDiffAggregateImpl<Type, Ext<BSKP, BSKW, Type, BasketType>, Exts...>::type;
    };
 
    template <int Type,
        typename BasketType,
        template <class, class, int, typename> class Ext>
    struct BasketDiffAggregateImpl<Type, BasketType, Ext>
    {
        using type = Ext<BSKP, BSKW, Type, BasketType>;
    };
 
    template <typename BasketType, int Type,
        template <class, class, int, typename> class... Exts>
    struct BasketDiffAggregate : BasketDiffAggregateImpl<Type, BasketType, PrimitiveDer, Exts...>
    {
    };
}
#endif
 
    template<typename _Derived, typename _Base>
    struct BasketComputeObject : public ComputeObject<_Derived>, public virtual _Base {
        using Base    = _Base;    
        using Derived = _Derived; 
        using Scalar  = typename Base::Scalar;
    protected:
        using ComputeObject<Derived>::derived;
    public:
        using ComputeObject<Derived>::compute; // Makes the default compute(container) accessible when using a CPU architecture
 
        template <typename IteratorBegin, typename IteratorEnd>
        PONCA_MULTIARCH inline FIT_RESULT compute(const IteratorBegin& begin, const IteratorEnd& end){
            Base::init();
            FIT_RESULT res = UNDEFINED;
 
            do {
                derived().startNewPass();
                for (auto it = begin; it != end; ++it){
                    derived().addNeighbor(*it);
                }
                res = Base::finalize();
            } while ( res == NEED_OTHER_PASS );
 
            return res;
        }
 
        template <typename IndexRange, typename PointContainer>
        PONCA_MULTIARCH inline FIT_RESULT computeWithIds(IndexRange ids, const PointContainer& points){
            Base::init();
            FIT_RESULT res = UNDEFINED;
 
            do {
                derived().startNewPass();
                for (const auto& i : ids){
                    derived().addNeighbor(points[i]);
                }
                res = Base::finalize();
            } while ( res == NEED_OTHER_PASS );
 
            return res;
        }
 
    protected:
        template<typename Func>
        FIT_RESULT computeMLSImpl(Func&& computeFunc, int mlsIter, Scalar epsilon) {
            FIT_RESULT res = UNDEFINED;
            const auto t = Base::m_w.evalScale();
            auto lastPos = Base::m_w.evalPos();
 
            for (int mm = 0; mm < mlsIter; ++mm) {
                Base::setWeightFunc({lastPos, t});
                res = computeFunc();
 
                if (Base::isStable()) {
                    auto newPos = Base::project(lastPos);
                    if (newPos.isApprox(lastPos, epsilon))
                        return res;
                    lastPos = newPos;
                } else {
                    return res;
                }
            }
            return res;
        }
 
    public:
        template<typename PointContainer>
        FIT_RESULT computeMLS(
            const PointContainer& points,
            const int mlsIter    = 5,
            const Scalar epsilon = Eigen::NumTraits<Scalar>::dummy_precision()
        ) {
            return computeMLSImpl(
                [&]() { return compute(points); },
                mlsIter, epsilon
            );
        }
 
        template<typename IndexRange, typename PointContainer>
        FIT_RESULT computeWithIdsMLS(
            const IndexRange& ids,
            const PointContainer& points,
            const int mlsIter    = 5,
            const Scalar epsilon = Eigen::NumTraits<Scalar>::dummy_precision()
        ) {
            return computeMLSImpl(
                [&]() { return computeWithIds(ids, points); },
                mlsIter, epsilon
            );
        }
    };
 
#define WRITE_COMPUTE_FUNCTIONS \
    using BasketComputeObject<Self, Base>::compute; \
    using BasketComputeObject<Self, Base>::computeWithIds; \
    using BasketComputeObject<Self, Base>::computeMLS; \
    using BasketComputeObject<Self, Base>::computeWithIdsMLS;
 
    template <typename BasketType, int Type,
        template <class, class, int, typename> class Ext0,
        template <class, class, int, typename> class... Exts>
    class BasketDiff : public BasketComputeObject<BasketDiff<BasketType, Type, Ext0, Exts...>,
                                                  typename internal::BasketDiffAggregate<BasketType, Type, Ext0, Exts...>::type>
    {
    private:
        using Self = BasketDiff;
    public:
        using Base = typename internal::BasketDiffAggregate<BasketType,Type,Ext0,Exts...>::type;
        using WeightFunction = typename BasketType::WeightFunction;
        using DataPoint = typename BasketType::DataPoint;
        using Scalar = typename BasketType::Scalar;
    WRITE_COMPUTE_FUNCTIONS
 
    PONCA_MULTIARCH inline bool addNeighbor(const DataPoint &_nei) {
        // compute weight
        auto wres = Base::m_w.w(_nei.pos(), _nei);
        typename Base::ScalarArray dw;
 
        if (wres.first > Scalar(0.)) {
            Base::addLocalNeighbor(wres.first, wres.second, _nei, dw);
            return true;
        }
        return false;
    }
};
 
    template <class P, class W,
        template <class, class, typename> class Ext0,
        template <class, class, typename> class... Exts>
    class Basket : public BasketComputeObject<Basket<P, W, Ext0, Exts...>,
                                              typename internal::BasketAggregate<P, W, Ext0, Exts...>::type>
    {
    private:
        using Self = Basket;
    public:
        using Base = typename internal::BasketAggregate<P, W, Ext0, Exts...>::type;
        using Scalar = typename P::Scalar;
        using VectorType = typename P::VectorType;
        using DataPoint = P;
        using WeightFunction = W;
 
        WRITE_COMPUTE_FUNCTIONS
 
        PONCA_MULTIARCH inline bool addNeighbor(const DataPoint &_nei) {
            // compute weight
            auto wres = Base::m_w.w(_nei.pos(), _nei);
 
            if (wres.first > Scalar(0.)) {
                Base::addLocalNeighbor(wres.first, wres.second, _nei);
                return true;
            }
            return false;
        }
    }; // class Basket
 
#undef WRITE_COMPUTE_FUNCTIONS
} //namespace Ponca