mongePatch.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 "./curvature.h"
#include "./weingarten.h"
#include "./heightField.h"
 
#include PONCA_MULTIARCH_INCLUDE_STD(cmath)
 
#include <Eigen/Dense>
 
namespace Ponca
{
    template <class DataPoint, class _NFilter, typename T>
    class MongePatch : public T
    {
        PONCA_FITTING_DECLARE_DEFAULT_TYPES
        static_assert(DataPoint::Dim == 3, "MongePatch is only valid in 3D");
 
    protected:
        enum
        {
            Check = Base::PROVIDES_PLANE && Base::PROVIDES_TANGENT_PLANE_BASIS &&
                    Base::PROVIDES_HEIGHTFIELD,         
            PROVIDES_MONGE_PATCH,                       
            PROVIDES_FIRST_FUNDAMENTAL_FORM_COMPONENTS, 
            PROVIDES_SECOND_FUNDAMENTAL_FORM_COMPONENTS 
        };
 
    public:
        PONCA_MULTIARCH inline MongePatch() : Base() { Base::init(); }
 
        PONCA_EXPLICIT_CAST_OPERATORS(MongePatch, mongePatchPrimitive)
 
        
        PONCA_MULTIARCH [[nodiscard]] inline Scalar potential() const { return Base::height(Scalar(0), Scalar(0)); }
 
        PONCA_MULTIARCH [[nodiscard]] inline Scalar potential(const VectorType& _q) const
        {
            const VectorType x = Base::worldToTangentPlane(_q);
            return Base::height(Base::getUFromLocalCoordinates(x), Base::getVFromLocalCoordinates(x)) -
                   Base::getHFromLocalCoordinates(x);
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline VectorType project(const VectorType& _q) const
        {
            VectorType x = Base::worldToTangentPlane(_q);
            Base::getHFromLocalCoordinates(x) =
                Base::height(Base::getUFromLocalCoordinates(x), Base::getVFromLocalCoordinates(x));
            return Base::tangentPlaneToWorld(x);
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline VectorType primitiveGradient() const
        {
            return Base::tangentPlaneToWorld(primitiveGradientLocal(), false);
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline VectorType primitiveGradient(const VectorType& _q) const
        {
            return Base::tangentPlaneToWorld(primitiveGradientLocal(Base::worldToTangentPlane(_q)), false);
        }
 
        PONCA_MULTIARCH [[nodiscard]] inline VectorType primitiveGradientLocal(
            const VectorType& _localQ = VectorType::Zero()) const
        {
            VectorType uVect  = Base::heightTangentULocal(_localQ);
            VectorType vVect  = Base::heightTangentVLocal(_localQ);
            VectorType cross  = uVect.cross(vVect);
            VectorType crossN = uVect.normalized().cross(vVect.normalized());
            return Base::heightTangentULocal(_localQ).cross(Base::heightTangentVLocal(_localQ));
        }
 
        PONCA_MULTIARCH inline void firstFundamentalFormComponents(Scalar& E, Scalar& F, Scalar& G) const
        {
            PONCA_MULTIARCH_STD_MATH(sqrt);
            const VectorType fu{Base::dh_du(), Scalar(1), Scalar(0)};
            const VectorType fv{Base::dh_dv(), Scalar(0), Scalar(1)};
            E = fu.dot(fu);
            F = fu.dot(fv);
            G = fv.dot(fv);
        }
 
        PONCA_MULTIARCH inline void secondFundamentalFormComponents(Scalar& L, Scalar& M, Scalar& N) const
        {
            PONCA_MULTIARCH_STD_MATH(sqrt);
            const VectorType fuu{Base::d2h_duu(), Scalar(0), Scalar(0)};
            const VectorType fuv{Base::d2h_duv(), Scalar(0), Scalar(0)};
            const VectorType fvv{Base::d2h_dvv(), Scalar(0), Scalar(0)};
            const VectorType fn = primitiveGradientLocal();
 
            L = fuu.dot(fn);
            M = fuv.dot(fn);
            ;
            N = fvv.dot(fn);
            ;
        }
    }; // class MongePatchPrimitive
 
    template <class DataPoint, class _NFilter, typename T>
    class MongePatchQuadraticFitImpl : public T
    {
        PONCA_FITTING_DECLARE_DEFAULT_TYPES
 
    protected:
        enum
        {
            Check = Base::PROVIDES_QUADRIC_HEIGHTFIELD && Base::PROVIDES_MONGE_PATCH
        };
 
    public:
        // we need to use dynamic matric to use ThinU, ThinV for solving
        using SampleMatrix                     = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>;
        using QuadraticHeightFieldCoefficients = typename Base::HeightFieldCoefficients;
 
        // protected:
    public:               // temporary DO NOT MERGE THIS
        SampleMatrix m_A; 
        QuadraticHeightFieldCoefficients m_b{QuadraticHeightFieldCoefficients::Zero()}; 
        bool m_planeIsReady{false};
 
    public:
        PONCA_EXPLICIT_CAST_OPERATORS(MongePatchQuadraticFitImpl, mongePatchQuadraticFit)
        PONCA_FITTING_DECLARE_INIT_ADD_FINALIZE
    }; // MongePatchQuadraticFitImpl
    template <class DataPoint, class _NFilter, typename T>
    class MongePatchRestrictedQuadraticFitImpl : public T
    {
        PONCA_FITTING_DECLARE_DEFAULT_TYPES
 
    protected:
        enum
        {
            Check = Base::PROVIDES_RESTRICTED_QUADRIC_HEIGHTFIELD && Base::PROVIDES_MONGE_PATCH
        };
 
    public:
        // we need to use dynamic matric to use ThinU, ThinV for solving
        using SampleMatrix                     = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>;
        using QuadraticHeightFieldCoefficients = typename Base::HeightFieldCoefficients;
 
    protected:
        SampleMatrix m_A; 
        QuadraticHeightFieldCoefficients m_b{QuadraticHeightFieldCoefficients::Zero()}; 
        bool m_planeIsReady{false};
 
    public:
        PONCA_EXPLICIT_CAST_OPERATORS(MongePatchRestrictedQuadraticFitImpl, mongePatchQuadraticFit)
        PONCA_FITTING_DECLARE_INIT_ADD_FINALIZE
    }; // MongePatchRestrictedQuadraticFitImpl
 
    template <class DataPoint, class _NFilter, typename T>
    using MongePatchQuadraticFit = WeingartenCurvatureEstimator<
        DataPoint, _NFilter,
        CurvatureEstimator<
            DataPoint, _NFilter,
            FundamentalFormWeingartenEstimator<
                DataPoint, _NFilter,
                MongePatchQuadraticFitImpl<
                    DataPoint, _NFilter,
                    MongePatch<DataPoint, _NFilter,
                               QuadraticHeightField<
                                   DataPoint, _NFilter,
                                   HeightField<DataPoint, _NFilter, CovariancePlaneFit<DataPoint, _NFilter, T>>>>>>>>;
 
    template <class DataPoint, class _NFilter, typename T>
    using MongePatchRestrictedQuadraticFit = WeingartenCurvatureEstimator<
        DataPoint, _NFilter,
        CurvatureEstimator<
            DataPoint, _NFilter,
            FundamentalFormWeingartenEstimator<
                DataPoint, _NFilter,
                MongePatchRestrictedQuadraticFitImpl<
                    DataPoint, _NFilter,
                    MongePatch<DataPoint, _NFilter,
                               RestrictedQuadraticHeightField<
                                   DataPoint, _NFilter,
                                   HeightField<DataPoint, _NFilter, CovariancePlaneFit<DataPoint, _NFilter, T>>>>>>>>;
 
#include "mongePatch.hpp"
 
} // namespace Ponca