gsNurbsBasis.h

Go to the documentation of this file.

#pragma once

#include <gsCore/gsForwardDeclarations.h>
#include <gsCore/gsRationalBasis.h>

#include <gsNurbs/gsBSplineBasis.h>
#include <gsNurbs/gsBoehm.h>


namespace gismo
{

template<class T>
class gsNurbsBasis : public gsRationalBasis<gsBSplineBasis<T> >
{
public:

    typedef gsKnotVector<T> KnotVectorType;

    typedef gsBSplineBasis<T> Family_t;

    typedef gsNurbs<T> GeometryType;

    typedef gsRationalBasis<gsBSplineBasis<T> > Base;

    typedef T Scalar_t;

    typedef gsConstantBasis<T> BoundaryBasisType;

    typedef memory::shared_ptr< gsNurbsBasis > Ptr;
    typedef memory::unique_ptr< gsNurbsBasis > uPtr;

    static const int Dim = 1;

public:

    gsNurbsBasis(T u0, T u1, unsigned interior, int degree, unsigned mult_interior=1):
    Base( gsBSplineBasis<T>(u0,01,interior,degree,mult_interior) )
    { 
        // if( ! check()  )
        //   gsWarn << "Warning: Inconsistent "<< *this<< "\n";
    }

    gsNurbsBasis() : Base() { }

    gsNurbsBasis( gsBSplineBasis<T> *bs, gsMatrix<T> w) :
    Base( bs, give(w) )  { }

    gsNurbsBasis( const gsKnotVector<T> & KV ) :
    Base( new gsBSplineBasis<T>(KV) )
    { }

    gsNurbsBasis(const gsKnotVector<T> & KV, gsMatrix<T> w) :
    Base( new gsBSplineBasis<T>(KV), give(w) ) { }

    gsNurbsBasis( const gsNurbsBasis & o) : Base(o) { }

    ~gsNurbsBasis() { }  //destructor

public:

    GISMO_CLONE_FUNCTION(gsNurbsBasis)
  
    GISMO_MAKE_GEOMETRY_NEW

    std::ostream &print(std::ostream &os) const
    {
        os << "NURBS Basis: deg=" << this->degree()
           << ", size=" << this->size() << ", knot vector:\n";
        os << this->knots() << ", weights: [ ";   
        os << this->weights().transpose() << " ]";   
        return os;
    }

    using Base::source;

// ***********************************************
// Additional members which forward to gsBSplineBasis
// ***********************************************

    T domainStart() const { return this->source().domainStart(); };

    T domainEnd() const { return this->source().domainEnd(); };

    inline unsigned firstActive(const T & u) const { return this->source().firstActive(u); }

    inline index_t numActive() const { return this->source().numActive(); }

    inline gsMatrix<unsigned,1> * firstActive(const gsMatrix<T,1> & u) const
    { return this->source().firstActive(u); };

    // /// Returns the knot vector of the basis
    const KnotVectorType & knots() const { return this->source().knots(); }
    KnotVectorType & knots()       { return this->source().knots(); }

    void insertKnot( T val, int i = 1)
    { 
        // TO DO: There is also Oslo Algorithm and others
        gsBoehm( this->knots(), this->weights(), val, i ); 
    }

    template <class It>
    void insertKnots( It begin, It end )
    {
        gsBoehmRefine( this->knots(), this->weights(), this->degree(), begin, end);
    }
  
    void uniformRefine(int numKnots = 1, int mul=1, int dir = -1)
    { 
        GISMO_UNUSED(dir);
        // TO DO ; replace this with global refinemnt by
        // Lane-Riesenfeld-like  Algorithm
        std::vector<T> newKnots;
        this->knots().getUniformRefinementKnots(numKnots, newKnots,mul);
        this->insertKnots( newKnots.begin(), newKnots.end() );
    }
  
    void uniform_k_refine(int const & i = 1) 
    { 
        //m_p += i;
        //m_knots->degreeElevate(i);
        //m_knots->uniformRefine();
    };

}; // class gsNurbsBasis


} // namespace gismo