mlsEvaluationScheme.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 "../concepts.h"
#include "../Filters/concepts.h" // ProvidesNeighborhoodFrame
#include "../Basket/concepts.h"  // ProvidesBasketUnitBase
#include "../defines.h"
#include "../enums.h"
 
#include "./project.h"
 
#include "Eigen/Core"
 
namespace Ponca
{
    template <typename Scalar>
    struct MLSEvaluationScheme
    {
        MLSEvaluationScheme(unsigned int _nIter = nIterDefault, Scalar _eps = epsDefault) : nIter(_nIter), eps(_eps) {}
 
        template <typename ComputeObject, typename ItB, typename ItE, typename Project = DirectProjectionOperator>
        PONCA_MULTIARCH inline FIT_RESULT compute(ComputeObject& _co, const ItB& _itb, const ItE& _ite,
                                                  const Project& _p = Project{}) const
        {
            return computeMLSImpl(_co, [&]() { return _co.compute(_itb, _ite); }, _p);
        }
 
        template <typename ComputeObject, typename PointContainer, typename Project = DirectProjectionOperator>
        PONCA_MULTIARCH inline FIT_RESULT compute(ComputeObject& _co, const PointContainer& container,
                                                  const Project& _p = Project{})
        {
            return compute(_co, std::begin(container), std::end(container), _p);
        }
 
        template <typename ComputeObject, typename IdxRange, typename PointContainer,
                  typename Project = DirectProjectionOperator>
        PONCA_MULTIARCH inline FIT_RESULT computeWithIds(ComputeObject& _co, const IdxRange& _range,
                                                         const PointContainer& _container,
                                                         const Project& _p = Project{}) const
        {
            return computeMLSImpl(_co, [&]() { return _co.computeWithIds(_range, _container); }, _p);
        }
 
        static constexpr Scalar epsDefault = Eigen::NumTraits<Scalar>::dummy_precision();
        static constexpr int nIterDefault = 5;
        Scalar eps = epsDefault;
        unsigned int nIter = nIterDefault;
 
    private:
        template <typename ComputeObject, typename Func, typename Project = DirectProjectionOperator>
            requires ProvidesNeighborhoodFilter<ComputeObject> && ProvidesBasketUnitBase<ComputeObject> &&
                     ProvidesImplicitPrimitive<ComputeObject>
        PONCA_MULTIARCH inline FIT_RESULT computeMLSImpl(ComputeObject& _co, Func&& _compute,
                                                         const Project& _p = Project{}) const
        {
            FIT_RESULT res = UNDEFINED;
            auto& frame    = _co.getNeighborFrame();
            auto lastPos   = frame.center();
 
            for (unsigned int mm = 0; mm < nIter; ++mm)
            {
                frame.changeNeighborhoodFrame(lastPos);
                res = _compute();
 
                if (_co.isStable())
                {
                    auto newPos = _p(_co, lastPos);
                    if (newPos.isApprox(lastPos, eps))
                        return res;
                    lastPos = newPos;
                }
                else
                {
                    return res;
                }
            }
 
            return res;
        }
    };
} // namespace Ponca