|| ||           || Doxygen's  

---

HxBSplineCurve.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 HxBSplineCurve_h
#define HxBSplineCurve_h

#include "HxBSplineBasis.h"
#include "HxPointR2.h"
#include "HxVectorR2.h"
#include "HxPointSetR2.h"
#include "HxVec2Double.h"
#include "HxPolyline2d.h"

#pragma warning (disable : 4786)

#include <vector>
using std::vector;
#include "HxIoFwd.h"


class HxBSplineCurve  {
public:
                            HxBSplineCurve();

                            HxBSplineCurve(const HxBSplineBasis& basis, 
                                           const HxPointSetR2& cp);

    static HxBSplineCurve   makeUniform(HxPolyline2d cp, int degree);

    static HxBSplineCurve   makeInterpolating(HxPolyline2d cp);

                            ~HxBSplineCurve();

    int                     ident() const;

    HxBSplineBasis          basis() const;

    HxBSplineType           curveType() const;

    int                     degree() const;

    double                  minT() const;

    double                  maxT() const;

    HxBSplineInterval       getInterval(double t1, double t2) const; 

    int                     numP() const;

    HxPointR2               P(int i) const;

    HxPointSetR2            allP() const;

    HxPolyline2d            controlP() const;

    double                  B(int i, double t) const;

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

    HxBSplineInterval       pathAffectedBy(int index) const;

    vector<int>             PThatAffectCAt(double t) const;

    vector<int>             PThatAffectCAt(const HxBSplineInterval& interval) const;

    HxPointR2               C(double t) const;

    HxVectorR2              dC(int order, double t) const;

    double                  kAtC(double t) const;

    double                  dTurnAngleAtC(double t) const;

    double                  length(int n=50) const;

    double                  length(const HxBSplineInterval& interval, int n=50) const;

    HxPointR2               center() const;

    HxPolyline2d            sampleC(int n=50) const;

//
// modifications applied the control points (not to this object!)
//

    HxBSplineCurve          changeAllP(const HxPointSetR2& p) const;

    HxBSplineCurve          translateAllP(const HxVectorR2& v) const;

    HxBSplineCurve          scaleAllP(double s) const;

    HxBSplineCurve          translateCurve(const HxVectorR2& v, double t) const;

    HxBSplineCurve          translateCurve(const HxPointR2& pDest, double t) const;

    HxBSplineCurve          translateCurve2(const HxVectorR2& v, double t) const;

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

    STD_OSTREAM&            dump(STD_OSTREAM&) const;

private:
    HxBSplineBasis          _basis;
    HxPointSetR2            _PVec;      // control points
    int                     _ident;

    static int              _nr;

    void                    makeDefault();
    void                    message(charPtr msg=0) const;
    HxPointR2               civ(int i,int order) const;
    int                     indexPVec(int i) const;
    double                  knot(int j) const;
};


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

inline int 
HxBSplineCurve::ident() const
{
    return _ident;
}

inline HxBSplineBasis 
HxBSplineCurve::basis() const
{
    return _basis;
}

inline HxBSplineType 
HxBSplineCurve::curveType() const
{
    return _basis.curveType();
}

inline int
HxBSplineCurve::degree() const
{
    return _basis.degree();
}

inline double 
HxBSplineCurve::minT() const
{ 
    return _basis.minT();
}

inline double
HxBSplineCurve::maxT() const
{ 
    return _basis.maxT();
}

inline HxBSplineInterval
HxBSplineCurve::getInterval(double t1, double t2) const
{
    return HxBSplineInterval(t1, t2,
        _basis.minT(), _basis.maxT(), _basis.curveType());
} 

inline double
HxBSplineCurve::B(int i, double t) const
{
    return _basis.B(i, t);
}

inline double
HxBSplineCurve::dB(int order, int i, double t) const
{
    return _basis.dB(order, i, t);
}

inline HxBSplineInterval
HxBSplineCurve::pathAffectedBy(int index) const
{
    return _basis.pathAffectedBy(index);
}

inline int 
HxBSplineCurve::numP() const
{ 
    return _basis.numB();
}

inline HxPointR2
HxBSplineCurve::P(int i) const
{
    if ( i < 0 || i >= numP() ) {
        message("(P) invalid index - setting to 0");
        i = 0;
    }
    return _PVec[i];
}

inline HxPointSetR2
HxBSplineCurve::allP() const
{
    return _PVec;
}

inline HxPolyline2d
HxBSplineCurve::controlP() const
{
    return HxPolyline2d(_PVec, (curveType() == closed));
}

inline  HxBSplineCurve
HxBSplineCurve::changeAllP(const HxPointSetR2& p) const
{
    return HxBSplineCurve(_basis, p);
}

inline HxPointR2
HxBSplineCurve::C(double t) const
{
    HxVectorR2 tmp = dC( 0, t);
    return HxPointR2(tmp.x(), tmp.y());
}

inline HxBSplineCurve
HxBSplineCurve::translateCurve(const HxPointR2& pDest, double t) const
{
    return translateCurve( HxVectorR2(pDest, C(t)), t);
}

inline double
HxBSplineCurve::knot(int j) const
{
    return _basis._knotsVec[j];
}

inline HxString
makeString(const HxBSplineCurve& i)
{
    return HxString("HxBSplineCurve") + makeString(i.ident());
}

#pragma warning (default : 4251)

#endif 

---