primitive.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 "enums.h"
#include <Eigen/Dense>
 
namespace Ponca
{
 
template < class DataPoint, class _WFunctor, typename T = void  >
class PrimitiveBase
{
protected:
    enum {
        PROVIDES_PRIMITIVE_BASE,    
    };
 
public:
    using Scalar     = typename DataPoint::Scalar;     
    using VectorType = typename DataPoint::VectorType; 
    using WFunctor   = _WFunctor;                      
private:
    int m_nbNeighbors {0};
 
    Scalar m_sumW {0};
 
protected:
 
    FIT_RESULT m_eCurrentState {UNDEFINED};
 
    WFunctor   m_w;
 
public:
    /**************************************************************************/
    /* Initialization                                                         */
    /**************************************************************************/
    PONCA_FITTING_APIDOC_SETWFUNC
    PONCA_MULTIARCH inline void setWeightFunc (const WFunctor& _w) {
        m_w  = _w;
    }
 
    PONCA_FITTING_APIDOC_INIT
    PONCA_MULTIARCH inline void init(const VectorType& _basisCenter = VectorType::Zero())
    {
        m_eCurrentState = UNDEFINED;
        startNewPass();
        m_w.init( _basisCenter );
    }
 
    PONCA_MULTIARCH inline bool isReady() const
    {
        return (m_eCurrentState == STABLE) || (m_eCurrentState == UNSTABLE);
    }
 
    PONCA_MULTIARCH inline bool isStable() const { return m_eCurrentState == STABLE; }
 
    PONCA_MULTIARCH inline bool needAnotherPass() const { return m_eCurrentState == NEED_OTHER_PASS; }
 
    PONCA_MULTIARCH inline int getNumNeighbors() const { return m_nbNeighbors; }
 
    PONCA_MULTIARCH inline Scalar getWeightSum() const { return m_sumW; }
 
    PONCA_MULTIARCH inline void startNewPass() {
        m_nbNeighbors = 0;
        m_sumW = Scalar(0);
    }
 
    PONCA_MULTIARCH inline const WFunctor& getWeightFunc() const
    {
        return m_w;
    }
 
 
    PONCA_MULTIARCH inline FIT_RESULT getCurrentState() const
    {
        return m_eCurrentState;
    }
 
    PONCA_FITTING_APIDOC_ADDNEIGHBOR
    PONCA_MULTIARCH inline bool addLocalNeighbor(Scalar w, const VectorType &, const DataPoint &) {
        m_sumW += w;
        ++(m_nbNeighbors);
        return true;
    }
 
    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 Primitive
 
 
 
 
 
template < class DataPoint, class _WFunctor, int Type, typename T>
class PrimitiveDer : public T
{
private:
    typedef T Base; 
protected:
    enum {
        Check = Base::PROVIDES_PRIMITIVE_BASE,    
        PROVIDES_PRIMITIVE_DERIVATIVE
    };
 
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 Scalar     = typename Base::Scalar;          
    using VectorType = typename Base::VectorType;      
    using MatrixType = typename DataPoint::MatrixType; 
    using WFunctor   = typename Base::WFunctor;        
    typedef Eigen::Matrix<Scalar, DataPoint::Dim, NbDerivatives, DerStorageOrder> VectorArray;
 
    typedef Eigen::Matrix<Scalar, 1, NbDerivatives> ScalarArray;
 
protected:
    // computation data
    ScalarArray m_dSumW;      
public:
 
    /************************************************************************/
    /* Initialization                                                       */
    /************************************************************************/
    PONCA_MULTIARCH inline void init(const VectorType &_evalPos)
    { Base::init(_evalPos); m_dSumW.setZero(); }
 
    /************************************************************************/
    /* Processing                                                           */
    /************************************************************************/
    PONCA_MULTIARCH inline bool addLocalNeighbor(Scalar w,
                                                 const VectorType &localQ,
                                                 const DataPoint &attributes,
                                                 ScalarArray &dw)
    {
        if( Base::addLocalNeighbor(w, localQ, attributes) ) {
            int spaceId = (Type & FitScaleDer) ? 1 : 0;
            // compute weight
            if (Type & FitScaleDer)
                dw[0] = Base::m_w.scaledw(attributes.pos(), attributes);
 
            if (Type & FitSpaceDer)
                dw.template segment<int(DataPoint::Dim)>(spaceId) = -Base::m_w.spacedw(attributes.pos(), attributes).transpose();
 
            m_dSumW += dw;
            return true;
        }
        return false;
    }
 
    /**************************************************************************/
    /* Use results                                                            */
    /**************************************************************************/
    PONCA_MULTIARCH inline constexpr bool isScaleDer() const {return bool(Type & FitScaleDer);}
    PONCA_MULTIARCH inline constexpr bool isSpaceDer() const {return bool(Type & FitSpaceDer);}
    PONCA_MULTIARCH inline constexpr unsigned int derDimension() const { return NbDerivatives;}
 
};
 
 
 
}