|| ||           || Doxygen's  

---

HxBSplineBasis.h

/*
 *  Copyright (c) 1998, University of Amsterdam, The Netherlands.
 *  All rights reserved.
 *
 *
 *  Author(s):
 *  Silvia D. Olabarriaga  (silvia@wins.uva.nl)
 *  Dennis Koelma (koelma@wins.uva.nl)
 */

#ifndef HxBSplineBasis_h
#define HxBSplineBasis_h

#include <vector>
using std::vector;

#include "HxStd.h"
#include "HxBSplineType.h"
#include "HxBSplineInterval.h"
#include "HxIoFwd.h"

class HxBSplineCurve;


enum HxBSplineKnotsAlg 
{ 
    uniformKnots,       // uniform spacing
    givenKnots          // any spacing
};


class HxBSplineBasis  {
public:
                        HxBSplineBasis();

                        HxBSplineBasis(HxBSplineType typeCurve, 
                            int degree, int nIntervals,
                            HxBSplineKnotsAlg typeKnots =uniformKnots, 
                            double minT =0.0, double maxT =1.0);

                        HxBSplineBasis(HxBSplineType typeCurve, int degree,
                                       const std::vector<double>& knots);

                        ~HxBSplineBasis();


    HxBSplineType       curveType() const;

    int                 degree() const;

    int                 nIntervals() const;

    HxBSplineKnotsAlg   knotsType() const;

    double              minT() const;

    double              maxT() const;

    double              knot(int j) const;

    std::vector<double> allKnots() const;

    int                 numB() const;

    double              B(int index, double t) const;

    double              dB(int order, int index, double t) const;

    HxBSplineInterval   pathAffectedBy(int index) const;


    HxBSplineBasis      insertKnot(double t, int n=1) const;

    STD_OSTREAM&        dump(STD_OSTREAM&) const;

// 
// these methods support the implementation
// of curve manipulation of higher level
// described in the NURBS book, p.512
// they should be protected in some way!
// 
    double              node(int i) const;
    int                 maxBasis(double t) const;
    double              nearestKnot(double t) const;

private:
    HxBSplineType       _curveType;
    int                 _degree;

    int                 _nIntervals;
    double              _minT;
    double              _maxT;
    HxBSplineKnotsAlg   _knotsType;

    // vector with knots
    vector <double>     _knotsVec;

    friend class HxBSplineCurve;

    void                makeDefault();
    void                message( charPtr msg=0 ) const;
    void                completeKnots( const vector<double>& knots);
    void                correctEnds( int i );
    vector<double>      makeUniformKnots();
    int                 internalBasisIndex( int i, double t) const;
    int                 whichInterval ( double t ) const;
    int                 isNullAt( int index, double t) const;
    double              nim(double t,int i,int M) const;
    double              dNim(int order, double t, int i,int M) const;
};

inline STD_OSTREAM&
operator<<(STD_OSTREAM& os, const HxBSplineBasis& b)
{
    return b.dump(os);
}

inline HxBSplineType 
HxBSplineBasis::curveType() const
{
    return _curveType; 
}

inline
int HxBSplineBasis::degree() const
{
    return _degree;
}


inline
int HxBSplineBasis::nIntervals() const
{
    return _nIntervals;
}

inline HxBSplineKnotsAlg 
HxBSplineBasis::knotsType() const 
{ 
    return _knotsType; 
}

inline double 
HxBSplineBasis::minT() const 
{ 
    return _minT; 
}

inline double
HxBSplineBasis::maxT() const
{ 
    return _maxT;
}

inline int 
HxBSplineBasis::numB() const
{ 
    switch ( curveType() ) {
      case closed:
            return _nIntervals; 
            break;
      case openRepeatEndPoints:
      case open:
      default:  // this case should never happen!
            return _nIntervals+degree(); 
            break;
    }
}

inline double 
HxBSplineBasis::knot(int i) const
{ 
    return _knotsVec[i];
}

inline vector<double> 
HxBSplineBasis::allKnots() const
{ 
    return _knotsVec;
}

inline int
HxBSplineBasis::isNullAt(int i, double t) const
{
    HxBSplineInterval interval = pathAffectedBy(i);
    return ! interval.contains(t);
}

#endif 

---