orientedSphereFit.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 "./algebraicSphere.h"
#include "./mean.h"          // used to define OrientedSphereFit
 
namespace Ponca
{
 
template < class DataPoint, class _NFilter, typename T >
class OrientedSphereFitImpl : public T
{
    PONCA_FITTING_DECLARE_DEFAULT_TYPES
 
protected:
    enum
    {
        Check = Base::PROVIDES_ALGEBRAIC_SPHERE &&
                Base::PROVIDES_MEAN_NORMAL &&
                Base::PROVIDES_MEAN_POSITION
    };
 
    // computation data
    Scalar  m_sumDotPN {0}, 
            m_sumDotPP {0}, 
            m_nume     {0}, 
            m_deno     {0}; 
public:
    PONCA_EXPLICIT_CAST_OPERATORS(OrientedSphereFitImpl,orientedSphereFit)
    PONCA_FITTING_DECLARE_INIT_ADD_FINALIZE
    PONCA_FITTING_IS_SIGNED(true)
}; //class OrientedSphereFitImpl
 
template < class DataPoint, class _NFilter, typename T>
using OrientedSphereFit =
OrientedSphereFitImpl<DataPoint, _NFilter,
        MeanPosition<DataPoint, _NFilter,
            MeanNormal<DataPoint, _NFilter,
                AlgebraicSphere<DataPoint, _NFilter, T>>>>;
 
template < class DataPoint, class _NFilter, int DiffType, typename T>
class OrientedSphereDerImpl : public T
{
    PONCA_FITTING_DECLARE_DEFAULT_TYPES
    PONCA_FITTING_DECLARE_DEFAULT_DER_TYPES
 
protected:
    enum
    {
        Check = Base::PROVIDES_ALGEBRAIC_SPHERE &
                Base::PROVIDES_MEAN_POSITION_DERIVATIVE &
                Base::PROVIDES_PRIMITIVE_DERIVATIVE,
        PROVIDES_ALGEBRAIC_SPHERE_DERIVATIVE,
        PROVIDES_NORMAL_DERIVATIVE
    };
 
    // computation data
    VectorArray m_dSumN {VectorArray::Zero()};     
    ScalarArray m_dSumDotPN {ScalarArray::Zero()}, 
                m_dSumDotPP {ScalarArray::Zero()}, 
                m_dNume {ScalarArray::Zero()},     
                m_dDeno {ScalarArray::Zero()};     
public:
    // results
    ScalarArray m_dUc {ScalarArray::Zero()}, 
                m_dUq {ScalarArray::Zero()}; 
    VectorArray m_dUl {VectorArray::Zero()}; 
public:
    PONCA_EXPLICIT_CAST_OPERATORS_DER(OrientedSphereDerImpl,orientedSphereDer)
    PONCA_FITTING_DECLARE_INIT_ADDDER_FINALIZE
 
    PONCA_MULTIARCH [[nodiscard]] inline ScalarArray dPotential() const;
 
    PONCA_MULTIARCH [[nodiscard]] inline VectorArray dNormal() const;
 
    PONCA_MULTIARCH [[nodiscard]] inline ScalarArray dprattNorm2() const
    {
        return   Scalar(2.) * Base::m_ul.transpose() * m_dUl
            - Scalar(4.) * Base::m_uq * m_dUc
            - Scalar(4.) * Base::m_uc * m_dUq;
    }
 
    PONCA_MULTIARCH [[nodiscard]] inline Scalar dprattNorm2(unsigned int _d) const
    {
        return   Scalar(2.) * m_dUl.col(_d).dot(Base::m_ul)
            - Scalar(4.) * m_dUc.col(_d)[0]*Base::m_uq
            - Scalar(4.) * m_dUq.col(_d)[0]*Base::m_uc;
    }
 
    PONCA_MULTIARCH [[nodiscard]] inline Scalar dprattNorm(unsigned int _d) const
    {
        PONCA_MULTIARCH_STD_MATH(sqrt);
        return sqrt(dprattNorm2(_d));
    }
 
    PONCA_MULTIARCH [[nodiscard]] inline Scalar dprattNorm() const
    {
        PONCA_MULTIARCH_STD_MATH(sqrt);
        return dprattNorm2().array().sqrt();
    }
 
    PONCA_MULTIARCH [[nodiscard]] inline bool applyPrattNorm();
 
}; //class OrientedSphereDerImpl
 
    template < class DataPoint, class _NFilter, int DiffType, typename T>
    using OrientedSphereDer =
        OrientedSphereDerImpl<DataPoint, _NFilter, DiffType,
            MeanPositionDer<DataPoint, _NFilter, DiffType, T>>;
 
#include "orientedSphereFit.hpp"
 
} //namespace Ponca