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 "concepts.h"
#include "basketUnit.h"
 
#include "../compute.h"
#include "../defines.h"
#include "../enums.h"
 
namespace Ponca
{
 
#define BSKNF typename BasketType::NeighborFilter
#define BSKP typename BasketType::DataPoint
#define BSKS typename BasketType::Scalar
#define BSKV typename BasketType::VectorType
 
#ifndef PARSED_WITH_DOXYGEN
    namespace internal
    {
        template <class P, class NF, typename Aggregate, template <class, class, typename> class Ext,
                  template <class, class, typename> class... Exts>
        struct BasketAggregateImpl
        {
            using type = typename BasketAggregateImpl<P, NF, Ext<P, NF, Aggregate>, Exts...>::type;
        };
 
        template <class P, class NF, typename Aggregate, template <class, class, typename> class Ext>
        struct BasketAggregateImpl<P, NF, Aggregate, Ext>
        {
            using type = Ext<P, NF, Aggregate>;
        };
 
        template <class P, class NF, template <class, class, typename> class... Exts>
        struct BasketAggregate : BasketAggregateImpl<P, NF, BasketUnitBase<P, NF>, 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, BSKNF, 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, BSKNF, Type, BasketType>;
        };
 
        template <typename BasketType, int Type, template <class, class, int, typename> class... Exts>
        struct BasketDiffAggregate : BasketDiffAggregateImpl<Type, BasketType, BasketDiffUnitBase, Exts...>
        {
        };
    } // namespace internal
#endif
 
    template <typename _Derived, typename _Base>
    struct BasketComputeObject : public ComputeObject<_Derived>, public _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;
        }
 
        // WARNING: Do not store anything in this class unless you know what you are doing.
        // Currently, each BasketDiff inherits "twice" from BasketComputeObject:
        //  - Through BasketComputeObject<Basket>
        //  - Through BasketComputeObject<BasketDiff>
        // According to the rules of C++, these classes have nothing in common and are as
        // different as an int and a std::vector. There is a high chance that the
        // BasketComputeObject<Basket> and BasketComputeObject<BasketDiff> subobjects
        // will become out of sync. In particular, you need to manually handle value
        // propagation between them to ensure that both instances see the same values when
        // needed.
    };
 
#define WRITE_COMPUTE_FUNCTIONS                     \
    using BasketComputeObject<Self, Base>::compute; \
    using BasketComputeObject<Self, Base>::computeWithIds;
 
    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 NeighborFilter = BSKNF;
        using DataPoint = BSKP;
        using Scalar = BSKS;
        using VectorType = BSKV;
        WRITE_COMPUTE_FUNCTIONS
 
        PONCA_MULTIARCH void init();
 
        PONCA_MULTIARCH void startNewPass();
 
        PONCA_MULTIARCH void finalize();
 
        PONCA_MULTIARCH bool addNeighbor(const DataPoint& _nei);
 
        PONCA_MULTIARCH void addLocalNeighbor(Scalar _w, const VectorType& _localQ, const DataPoint& _nei,
                                              typename Base::ScalarArray& _dw);
    };
 
    template <class P, class NF, template <class, class, typename> class Ext0,
              template <class, class, typename> class... Exts>
        requires IsPoint<P>
    class Basket : public BasketComputeObject<Basket<P, NF, Ext0, Exts...>,
                                              typename internal::BasketAggregate<P, NF, Ext0, Exts...>::type>
    {
    private:
        using Self = Basket;
 
    public:
        using Base = typename internal::BasketAggregate<P, NF, Ext0, Exts...>::type;
        using Scalar     = typename P::Scalar;
        using VectorType = typename P::VectorType;
        using DataPoint = P;
        using NeighborFilter = NF;
 
        WRITE_COMPUTE_FUNCTIONS
 
        PONCA_MULTIARCH void init();
 
        PONCA_MULTIARCH void startNewPass();
 
        PONCA_MULTIARCH FIT_RESULT finalize();
 
        PONCA_MULTIARCH bool addNeighbor(const DataPoint& _nei);
 
        PONCA_MULTIARCH void addLocalNeighbor(typename P::Scalar _w, const typename P::VectorType& _localQ,
                                              const P& _nei);
    }; // class Basket
 
#undef WRITE_COMPUTE_FUNCTIONS
} // namespace Ponca
 
#include "basket.hpp"