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 memory::unique_ptr<gsGeometry<T> > gsGeoPtr;
    typedef memory::unique_ptr<gsBasis<T> >    gsBasisPtr;
    
    typedef gsBSplineBasis<T> Family_t;
 
    typedef gsNurbs<T> GeometryType;
 
    typedef gsRationalBasis<gsBSplineBasis<T> > Base;
 
    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,u1,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( gsBSplineBasis<T> bs, gsMatrix<T> w) :
    Base(new gsBSplineBasis<T>(), give(w))
    {
        *this->m_src = give(bs);
    }
 
    explicit gsNurbsBasis( gsKnotVector<T> KV ) :
    Base( new gsBSplineBasis<T>(give(KV)) )
    { }
 
    gsNurbsBasis(gsKnotVector<T> KV, gsMatrix<T> w) :
    Base( new gsBSplineBasis<T>(give(KV)), give(w) ) { }
 
    gsNurbsBasis( const gsNurbsBasis & o) : Base(o) { }
 
    virtual ~gsNurbsBasis();
 
public:
 
    GISMO_CLONE_FUNCTION(gsNurbsBasis)
 
    gsGeoPtr makeGeometry( gsMatrix<T>coefs ) const;
 
    static gsBasisPtr create(std::vector<KnotVectorType> cKV, gsMatrix<T> weights);
    using Base::create;
 
    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 index_t firstActive(const gsMatrix<T,1> & u) const
    { return this->source().firstActive(u.value()); };
 
    // /// 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) 
    {
        GISMO_NO_IMPLEMENTATION
        //m_p += i;
        //m_knots->degreeElevate(i);
        //m_knots->uniformRefine();
    };
 
}; // class gsNurbsBasis
 
 
} // namespace gismo
 
 
// *****************************************************************
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsNurbsBasis.hpp)
#else
#ifdef gsNurbsBasis_EXPORT
#include GISMO_HPP_HEADER(gsNurbsBasis.hpp)
#undef  EXTERN_CLASS_TEMPLATE
#define EXTERN_CLASS_TEMPLATE CLASS_TEMPLATE_INST
#endif
namespace gismo
{
EXTERN_CLASS_TEMPLATE gsNurbsBasis<real_t>;
}
#endif
// *****************************************************************