gsFitting.h

Go to the documentation of this file.

#pragma once

#include <gsCore/gsForwardDeclarations.h>
#include <vector>
#include <gsMSplines/gsMappedBasis.h>
#include <gsMSplines/gsMappedSpline.h>

namespace gismo
{

template<class T>
class gsFitting
{
public:
    gsFitting()
    {
        m_basis = NULL;
        m_result= NULL ;
    }

    gsFitting(gsMatrix<T> const & param_values, 
              gsMatrix<T> const & points, 
              gsBasis<T>  & basis);

    gsFitting(gsMatrix<T> const & param_values, 
              gsMatrix<T> const & points,
              gsVector<index_t>  offset,
              gsMappedBasis<2,T>  & mbasis) ;

    virtual ~gsFitting();

public:

    void compute(T lambda = 0);

    void parameterCorrection(T accuracy = 1e-8,
                             index_t maxIter = 10,
                             T tolOrth = 1e-6);

    void computeErrors();

    void computeMaxNormErrors();

    void computeApproxError(T & error, int type = 0) const;

    void get_Error(std::vector<T>& errors, int type = 0) const;

    T minPointError() const { return m_min_error; }

    T maxPointError() const { return m_max_error; }

    const std::vector<T> & pointWiseErrors() const
    {
        return m_pointErrors;
    }

    size_t numPointsBelow(T threshold) const
    { 
        const size_t result=
            std::count_if(m_pointErrors.begin(), m_pointErrors.end(), 
                          GS_BIND2ND(std::less<T>(), threshold));
        return result; 
    }

    void iterativeCompute( T const & tolerance, unsigned const & num_iters = 10);

    void applySmoothing(T lambda, gsSparseMatrix<T> & A_mat);
    gsSparseMatrix<T> smoothingMatrix(T lambda) const;
    void assembleSystem(gsSparseMatrix<T>& A_mat, gsMatrix<T>& B);


public:

    gsGeometry<T> * result() const { return m_result; }

    const gsMappedSpline<2,T> & mresult() const { return m_mresult; }

    const gsBasis<T> & getBasis() const {return *static_cast<const gsBasis<T>*>(m_basis);}

    void setBasis(gsBasis<T> & basis) {m_basis=&basis;}

    gsMatrix<T> & getreturnParamValues() {return m_param_values;}
    gsMatrix<T> & returnParamValues() {return m_param_values;}

    gsMatrix<T> returnPoints() const {return m_points;}

    void setConstraints(const gsSparseMatrix<T>& lhs, const gsMatrix<T>& rhs)
    {
        m_constraintsLHS = lhs;
        m_constraintsRHS = rhs;
    }

    void setConstraints(const std::vector<index_t>& indices,
                        const std::vector<gsMatrix<T> >& coefs);

    void setConstraints(const std::vector<boxSide>& fixedSides);

    void setConstraints(const std::vector<boxSide>& fixedSides,
            const std::vector<gsBSpline<T> >& fixedCurves);
    void setConstraints(const std::vector<boxSide>& fixedSides,
            const std::vector<gsGeometry<T> * >& fixedCurves);


private:
    void extendSystem(gsSparseMatrix<T>& A_mat, gsMatrix<T>& m_B);

protected:

    //gsOptionList

    gsMatrix<T> m_param_values;

    gsMatrix<T> m_points;

    // Patch offsets
    gsVector<index_t> m_offset;

    gsFunctionSet<T> * m_basis;

    gsGeometry<T> * m_result;

    gsMappedSpline<2,T>  m_mresult;

    // All point-wise errors
    std::vector<T> m_pointErrors;

    mutable T m_last_lambda;

    T m_max_error;

    T m_min_error;

    gsSparseMatrix<T> m_constraintsLHS;

    gsMatrix<T>       m_constraintsRHS;

private:
    //void applySmoothing(T lambda, gsMatrix<T> & A_mat);

}; // class gsFitting


#ifdef GISMO_WITH_PYBIND11

  void pybind11_init_gsFitting(pybind11::module &m);

#endif // GISMO_WITH_PYBIND11


}// namespace gismo


#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsFitting.hpp)
#endif