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 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 <typename BasketType, int Type,
        typename Aggregate,
        template <class, class, int, typename> class Ext,
        template <class, class, int, typename> class... Exts>
    struct BasketDiffAggregateImpl
    {
        using type = typename BasketDiffAggregateImpl<BasketType, Type, Ext<BSKP, BSKW, Type, Aggregate>, Exts...>::type;
    };
 
    template <typename BasketType, int Type,
        typename Aggregate,
        template <class, class, int, typename> class Ext>
    struct BasketDiffAggregateImpl<BasketType, Type, Aggregate, Ext>
    {
        using type = Ext<BSKP, BSKW, Type, Aggregate>;
    };
 
    template <typename BasketType, int Type,
        template <class, class, int, typename> class... Exts>
    struct BasketDiffAggregate : BasketDiffAggregateImpl<BasketType, Type, BasketType, PrimitiveDer, Exts...>
    {
    };
}
#endif
 
    template <typename Derived>
    struct ComputeObject {
    protected:
        Derived& derived() { return static_cast<Derived&>(*this); }
    public:
 
#ifdef PONCA_CPU_ARCH
        template <typename Container>
        FIT_RESULT compute(const Container& c) {
            return derived().compute(std::begin(c), std::end(c));
        }
#endif
 
        template <typename IteratorBegin, typename IteratorEnd>
        PONCA_MULTIARCH inline FIT_RESULT compute(const IteratorBegin& begin, const IteratorEnd& end) { return UNDEFINED; };
 
        template <typename IndexRange, typename PointContainer>
        PONCA_MULTIARCH inline FIT_RESULT computeWithIds(IndexRange /*ids*/, const PointContainer& /*points*/) { return UNDEFINED; };
    }; // struct ComputeObject
 
#define WRITE_COMPUTE_FUNCTIONS                                                                       \
 \
 \
                         \
                                                                         \
    template <typename IteratorBegin, typename IteratorEnd>                                           \
    PONCA_MULTIARCH inline                                                                            \
    FIT_RESULT compute(const IteratorBegin& begin, const IteratorEnd& end){                           \
        Base::init();                                                                                 \
        FIT_RESULT res = UNDEFINED;                                                                   \
        do {                                                                                          \
            Self::startNewPass();                                                                     \
            for (auto it = begin; it != end; ++it){                                                   \
                Self::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){                          \
        this->init();                                                                                 \
        FIT_RESULT res = UNDEFINED;                                                                   \
        do {                                                                                          \
            Self::startNewPass();                                                                     \
            for (const auto& i : ids){                                                                \
                this->addNeighbor(points[i]);                                                         \
            }                                                                                         \
            res = this->finalize();                                                                   \
        } while ( res == NEED_OTHER_PASS );                                                           \
        return res;                                                                                   \
    }
 
    template <typename BasketType, int Type,
        template <class, class, int, typename> class Ext0,
        template <class, class, int, typename> class... Exts>
    class BasketDiff : public ComputeObject<BasketDiff<BasketType, Type, Ext0, Exts...>>,
                       public internal::BasketDiffAggregate<BasketType, Type, Ext0, Exts...>::type {
    private:
        using Self   = BasketDiff;
    public:
    using Base = typename internal::BasketDiffAggregate<BasketType, Type, Ext0, Exts...>::type;
    using WeightFunction = BSKW;
    using DataPoint = BSKP;
    using Scalar = typename DataPoint::Scalar;
 
    using ComputeObject<Self>::compute; // Make the default compute accessible
    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 ComputeObject<Basket<P, W, Ext0, Exts...>>,
                   public 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 DataPoint = P;
        using WeightFunction = W;
 
        using ComputeObject<Self>::compute; // Make the default compute accessible
        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
 
} //namespace Ponca