gsLagrangePoly.h

// defined over a Lagrange basis
 
#pragma once
 
#include <ostream>
 
#include <gsCore/gsLinearAlgebra.h>
#include <gsCore/gsGeometry.h>
#include "gsLagrangeBasis.h"
 
 
namespace gismo
{
 
template<class T>
class gsLagrangePoly : public gsGeoTraits<1,T>::GeometryBase
{
 
public:
    typedef gsLagrangeBasis<T> Basis;
    typedef typename gsGeoTraits<1,T>::GeometryBase Base;
 
    typedef memory::shared_ptr< gsLagrangePoly > Ptr;
 
    typedef memory::unique_ptr< gsLagrangePoly > uPtr;
 
    gsLagrangePoly() : Base() { }
 
    gsLagrangePoly( const Basis & basis, gsMatrix<T> coefs ) :
    Base( basis, give(coefs)) { }
 
    gsLagrangePoly( const unsigned & p, const gsMatrix<T> & coefs, const T & u0=0, const T & u1= 1) : Base()
    {
        gsLagrangeBasis<T> * lagrange_basis = new Basis(u0,u1,p-1);
        Base::m_coefs=coefs;
        Base::m_basis=lagrange_basis;
        GISMO_ASSERT( lagrange_basis->size() == this->m_coefs.rows(),
                      "The coefficient matrix of the geometry (rows="<<this->m_coefs.rows()<<") does not match the number of basis functions in its basis("<< lagrange_basis->size() <<").");
    }
 
    gsLagrangePoly( const gsBSpline<T> & bezier_curve, int part) : Base()
    {
        gsBSplineBasis<T> basis = bezier_curve.basis();
        gsKnotVector<T> * bezier_knots = &basis.knots();
        T start = (*bezier_knots)[part];
        T end = (*bezier_knots)[part+1];
        gsLagrangeBasis<T> * lagrange_basis = new gsLagrangeBasis<T>(0,1, basis.degree()-1);
        gsMatrix<T> lagrange_coeffs;
        const std::vector<T> * lagrange_breaks = lagrange_basis->get_m_breaks();
        gsMatrix<T> u(1,lagrange_breaks->size());
        for(unsigned i = 0;i<lagrange_breaks->size();i++)
        {
            u(0,i)=start+(end-start)*lagrange_breaks->at(i);
        }
        bezier_curve.eval_into(u,lagrange_coeffs);
        Base::m_coefs=lagrange_coeffs.transpose();
        Base::m_basis=lagrange_basis;
        GISMO_ASSERT( lagrange_basis->size() == this->m_coefs.rows(),
                      "The coefficient matrix of the geometry (rows="<<this->m_coefs.rows()<<") does not match the number of basis functions in its basis("<< lagrange_basis->size() <<").");
    }
 
    
public:
 
    GISMO_BASIS_ACCESSORS
        
    GISMO_CLONE_FUNCTION(gsLagrangePoly)
 
    
    std::ostream &print(std::ostream &os) const
    {
        os << "Lagrange curve of degree "<<
            this->basis().degree()<< ", over [" << domainStart()
         << " " << domainEnd() << "] with breaks ";
        for ( typename std::vector<T>::const_iterator itr=
              this->basis().get_m_breaks()->begin(); itr != this->basis().get_m_breaks()->end(); ++itr )
            os << *itr << ", ";
        return os;
    }
 
 
// Additional members for univariate B-Splines
 
    T domainStart() const { return this->basis().get_m_start(); }
 
    T domainEnd() const { return this->basis().get_m_end(); }
 
    gsBSpline<T> * transformToBezier()
    {
        gsMatrix<T> transformMat;
        this->basis().getTransformationLagrangeBezier(transformMat);
        gsMatrix<T> newCoefs = transformMat*this->coefs();
        unsigned deg = this->basis().degree();
        gsBSpline<T> * bezCurve = new gsBSpline<T>(0.0,1.0,0,deg,newCoefs);
        return bezCurve;
    }
 
    void reparameterizeToZeroOne()
    {
        this->basis().reparameterizeToZeroOne();
    }
 
// Data members
private:
 
}; // class gsLagrangePoly
 
 
 
}; // namespace gismo