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 "../../defines.h"
#include "../concepts.h"
 
#include "../primitive/algebraicSphere.h" // used to define OrientedSphereFit
#include "../tools/mean.h"                // used to define OrientedSphereFit
 
#define ORIENTED_SPHERE_FIT_REQUIREMENTS ProvidesAlgebraicSphere<T>&& ProvidesMeanPosition<T>&& ProvidesMeanNormal<T>
#define ORIENTED_SPHERE_DER_REQUIREMENTS \
    ProvidesBasketDiffUnitBase<T>&& ProvidesAlgebraicSphere<T>&& ProvidesMeanPositionDerivative<T>
 
namespace Ponca
{
 
    template <class DataPoint, class _NFilter, typename T>
        requires ORIENTED_SPHERE_FIT_REQUIREMENTS
    class OrientedSphereFitImpl : public T
    {
        PONCA_FITTING_DECLARE_DEFAULT_TYPES
 
    protected:
        // 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>
        requires ORIENTED_SPHERE_DER_REQUIREMENTS
    class OrientedSphereDerImpl : public T
    {
        PONCA_FITTING_DECLARE_DEFAULT_TYPES
        PONCA_FITTING_DECLARE_DEFAULT_DER_TYPES
 
    protected:
        // 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_EXPLICIT_CAST_OPERATORS_DER(OrientedSphereDerImpl, algebraicSphereDer)
        PONCA_EXPLICIT_CAST_OPERATORS_DER(OrientedSphereDerImpl, implicitPrimitiveDer)
 
        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 ScalarArray 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