unorientedSphereFit.h

/*
 Copyright (C) 2013 Gael Guennebaud <gael.guennebaud@inria.fr>
 
 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 UnorientedSphereFit
 
#include <Eigen/Dense>
 
namespace Ponca
{
    template <class DataPoint, class _NFilter, typename T>
    class UnorientedSphereFitImpl : public T
    {
        PONCA_FITTING_DECLARE_DEFAULT_TYPES
 
    protected:
        enum
        {
            Check = Base::PROVIDES_ALGEBRAIC_SPHERE && Base::PROVIDES_MEAN_POSITION
        };
 
        typedef Eigen::Matrix<Scalar, DataPoint::Dim + 1, 1> VectorB;
        typedef Eigen::Matrix<Scalar, DataPoint::Dim + 1, DataPoint::Dim + 1> MatrixBB;
 
    public:
        using Solver = Eigen::EigenSolver<MatrixBB>;
 
        MatrixBB m_matA{MatrixBB::Zero()}; 
        MatrixBB m_matQ{MatrixBB::Zero()}; 
        Scalar m_sumDotPP{0};              
        Solver m_solver;
 
    public:
        PONCA_EXPLICIT_CAST_OPERATORS(UnorientedSphereFitImpl, unorientedSphereFit)
        PONCA_FITTING_DECLARE_INIT_ADD_FINALIZE
        PONCA_FITTING_IS_SIGNED(false)
 
    }; // class UnorientedSphereFitImpl
 
    template <class DataPoint, class _NFilter, typename T>
    using UnorientedSphereFit =
        UnorientedSphereFitImpl<DataPoint, _NFilter,
                                MeanPosition<DataPoint, _NFilter, AlgebraicSphere<DataPoint, _NFilter, T>>>;
 
    template <class DataPoint, class _NFilter, int DiffType, typename T>
    class UnorientedSphereDerImpl : public T
    {
    protected:
        PONCA_FITTING_DECLARE_DEFAULT_TYPES
        PONCA_FITTING_DECLARE_DEFAULT_DER_TYPES
 
        using VectorB  = typename Base::VectorB;
        using MatrixBB = typename Base::MatrixBB;
 
    protected:
        enum
        {
            Check = Base::PROVIDES_ALGEBRAIC_SPHERE & Base::PROVIDES_MEAN_POSITION_DERIVATIVE &
                    Base::PROVIDES_PRIMITIVE_DERIVATIVE,
            PROVIDES_ALGEBRAIC_SPHERE_DERIVATIVE,
            PROVIDES_NORMAL_DERIVATIVE
        };
 
    protected:
        // computation data
        MatrixBB m_dmatA[Base::NbDerivatives];
        ScalarArray m_dSumDotPP{ScalarArray::Zero()};
 
    public:
        // results
        ScalarArray m_dUc{ScalarArray::Zero()};
        VectorArray m_dUl{VectorArray::Zero()};
        ScalarArray m_dUq{ScalarArray::Zero()};
 
    public:
        PONCA_EXPLICIT_CAST_OPERATORS_DER(UnorientedSphereDerImpl, unorientedSphereDer)
 
        PONCA_FITTING_DECLARE_INIT_ADDDER_FINALIZE
 
        PONCA_MULTIARCH inline ScalarArray dPotential() const;
        PONCA_MULTIARCH inline VectorArray dNormal() const;
 
    }; // class UnorientedSphereDerImpl
 
    template <class DataPoint, class _NFilter, int DiffType, typename T>
    using UnorientedSphereDer =
        UnorientedSphereDerImpl<DataPoint, _NFilter, DiffType, MeanPositionDer<DataPoint, _NFilter, DiffType, T>>;
 
} // namespace Ponca
 
#include "unorientedSphereFit.hpp"