basketUnit.h

/*
 Copyright (C) 2014 Nicolas Mellado <nmellado0@gmail.com>
 
 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 "concepts.h"
 
#include <Eigen/Dense>
 
namespace Ponca
{

    template <class DataPoint, class _NFilter, typename T = void>
    class BasketUnitBase
    {
    public:
        using Scalar         = typename DataPoint::Scalar;     
        using VectorType     = typename DataPoint::VectorType; 
        using NeighborFilter = _NFilter;                       
        using NeighborFrame  = typename NeighborFilter::NeighborhoodFrame;
 
    private:
        int m_nbNeighbors{0};

        Scalar m_sumW{0};
 
    protected:
        NeighborFilter m_nFilter;

        FIT_RESULT m_eCurrentState{UNDEFINED};
 
    public:
        /**************************************************************************/
        /* Initialization                                                         */
        /**************************************************************************/
        PONCA_FITTING_APIDOC_SETWFUNC
        PONCA_MULTIARCH inline bool setNeighborFilter(const NeighborFilter& _nFilter)
        {
            m_nFilter = _nFilter;
            return true;
        }
 
        PONCA_FITTING_APIDOC_INIT
        PONCA_MULTIARCH inline void init()
        {
            m_eCurrentState = UNDEFINED;
            startNewPass();
        }

        PONCA_MULTIARCH [[nodiscard]] inline bool isReady() const
        {
            return (m_eCurrentState == STABLE) || (m_eCurrentState == UNSTABLE);
        }

        PONCA_MULTIARCH [[nodiscard]] inline bool isStable() const { return m_eCurrentState == STABLE; }

        PONCA_MULTIARCH [[nodiscard]] inline bool needAnotherPass() const { return m_eCurrentState == NEED_OTHER_PASS; }

        PONCA_MULTIARCH [[nodiscard]] inline int getNumNeighbors() const { return m_nbNeighbors; }

        PONCA_MULTIARCH [[nodiscard]] inline Scalar getWeightSum() const { return m_sumW; }

        PONCA_MULTIARCH inline void startNewPass()
        {
            m_nbNeighbors = 0;
            m_sumW        = Scalar(0);
        }

        PONCA_MULTIARCH inline const NeighborFilter& getNeighborFilter() const { return m_nFilter; }
 
        PONCA_MULTIARCH inline NeighborFrame& getNeighborFrame() { return m_nFilter.frame(); }
        PONCA_MULTIARCH inline const NeighborFrame& getNeighborFrame() const { return m_nFilter.frame(); }
 
    public:
        PONCA_MULTIARCH [[nodiscard]] inline FIT_RESULT getCurrentState() const { return m_eCurrentState; }
 
        PONCA_FITTING_APIDOC_ADDNEIGHBOR
        PONCA_MULTIARCH inline void addLocalNeighbor(Scalar w, const VectorType&, const DataPoint&)
        {
            m_sumW += w;
            ++(m_nbNeighbors);
        }
 
        PONCA_FITTING_APIDOC_FINALIZE
        PONCA_MULTIARCH inline FIT_RESULT finalize()
        {
            // handle specific configurations
            if (m_sumW == Scalar(0.) || m_nbNeighbors < 1)
            {
                return m_eCurrentState = UNDEFINED;
            }
            return m_eCurrentState = STABLE;
        }
 
    }; // class BasketUnit

    template <class DataPoint, class _NFilter, int Type, typename T>
        requires ProvidesBasketUnitBase<T>
    class BasketDiffUnitBase : public T
    {
        PONCA_FITTING_DECLARE_DEFAULT_TYPES
        PONCA_FITTING_DECLARE_MATRIX_TYPE
    protected:
        static constexpr int NbDerivatives =
            ((Type & FitScaleDer) ? 1 : 0) + ((Type & FitSpaceDer) ? DataPoint::Dim : 0);
        static constexpr int DerStorageOrder = (Type & FitSpaceDer) ? Eigen::RowMajor : Eigen::ColMajor;
 
    public:
        using VectorArray = Eigen::Matrix<Scalar, DataPoint::Dim, NbDerivatives, DerStorageOrder>;

        using ScalarArray = Eigen::Matrix<Scalar, 1, NbDerivatives>;
 
    protected:
        // computation data
        ScalarArray m_dSumW; 
 
    public:
        /************************************************************************/
        /* Initialization                                                       */
        /************************************************************************/
        PONCA_MULTIARCH inline void init()
        {
            Base::init();
            m_dSumW.setZero();
        }
 
        /************************************************************************/
        /* Processing                                                           */
        /************************************************************************/
        PONCA_MULTIARCH inline void addLocalNeighbor(Scalar w, const VectorType& localQ, const DataPoint& attributes,
                                                     ScalarArray& dw)
        {
            Base::addLocalNeighbor(w, localQ, attributes);
            // call the Primitive Fit (without dw)
            int spaceId = (Type & FitScaleDer) ? 1 : 0;
            // compute weight
            if (Type & FitScaleDer)
                dw[0] = Base::getNeighborFilter().scaledw(attributes.pos(), attributes);
 
            if (Type & FitSpaceDer)
                dw.template segment<int(DataPoint::Dim)>(spaceId) =
                    -Base::getNeighborFilter().spacedw(attributes.pos(), attributes).transpose();
 
            m_dSumW += dw;
        }
 
        /**************************************************************************/
        /* Use results                                                            */
        /**************************************************************************/
        PONCA_MULTIARCH [[nodiscard]] static inline constexpr bool isScaleDer() { return bool(Type & FitScaleDer); }
        PONCA_MULTIARCH [[nodiscard]] static inline constexpr bool isSpaceDer() { return bool(Type & FitSpaceDer); }
        PONCA_MULTIARCH [[nodiscard]] static inline constexpr unsigned int derDimension() { return NbDerivatives; }
    };
 
} // namespace Ponca