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 "../concepts.h"
 
#include "../extensions/heightField.h"
#include "../extensions/weingarten.h"
#include "../utils.h"
 
#include PONCA_MULTIARCH_INCLUDE_STD(cmath)
 
#include <Eigen/Dense>
 
#define MONGE_PATCH_REQUIREMENTS ProvidesTangentPlaneBasis<T>&& ProvidesHeightField<T>&& Is3D<DataPoint>
#define MONGE_PATCH_FIT_REQUIREMENTS ProvidesImplicitPrimitive<T>&& ProvidesMongePatch<T>
 
namespace Ponca
{
    template <class DataPoint, class _NFilter, typename T>
        requires MONGE_PATCH_REQUIREMENTS
    class MongePatch : public T
    {
        PONCA_FITTING_DECLARE_DEFAULT_TYPES
        PONCA_MULTIARCH inline MongePatch() : Base() { Base::init(); }
 
        PONCA_EXPLICIT_CAST_OPERATORS(MongePatch, mongePatchPrimitive)
        PONCA_EXPLICIT_CAST_OPERATORS(MongePatch, implicitPrimitive)
        PONCA_EXPLICIT_CAST_OPERATORS(MongePatch, firstFondamentalFormComponent)
        PONCA_EXPLICIT_CAST_OPERATORS(MongePatch, secondFondamentalFormComponent)
 
        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>
        requires MONGE_PATCH_FIT_REQUIREMENTS
    class MongePatchQuadraticFitImpl : public MultipassStatus<DataPoint, _NFilter, T>
    {
        PONCA_FITTING_DECLARE_MULTIPASS_TYPES
    private:
        // 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()}; 
    public:
        PONCA_EXPLICIT_CAST_OPERATORS(MongePatchQuadraticFitImpl, mongePatchQuadraticFit)
        PONCA_FITTING_DECLARE_INIT_ADD_FINALIZE
    }; // MongePatchQuadraticFitImpl
    template <class DataPoint, class _NFilter, typename T>
        requires MONGE_PATCH_FIT_REQUIREMENTS
    class MongePatchRestrictedQuadraticFitImpl : public MultipassStatus<DataPoint, _NFilter, T>
    {
        PONCA_FITTING_DECLARE_MULTIPASS_TYPES
    private:
        // 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()}; 
    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,
        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,
        FundamentalFormWeingartenEstimator<
            DataPoint, _NFilter,
            MongePatchRestrictedQuadraticFitImpl<
                DataPoint, _NFilter,
                MongePatch<DataPoint, _NFilter,
                           RestrictedQuadraticHeightField<
                               DataPoint, _NFilter,
                               HeightField<DataPoint, _NFilter, CovariancePlaneFit<DataPoint, _NFilter, T>>>>>>>;
 
#include "mongePatch.hpp"
 
} // namespace Ponca