|| ||           || Doxygen's  

---

HxSampledBSplineCurve.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 HxSampledBSplineCurve_h
#define HxSampledBSplineCurve_h

#include "HxBSplineCurve.h"
#include "HxSampledBSplineInterval.h"
#include "HxIoFwd.h"


enum HxBSplineSamplingAlg
{ 
    samplingResolution,
    samplingInterval
};


class HxSampledBSplineCurve  {
public:
                                HxSampledBSplineCurve();

                                HxSampledBSplineCurve(
                                    const HxBSplineCurve& curve, int nSamples,
                                    HxBSplineSamplingAlg algorithm =samplingResolution);

                                HxSampledBSplineCurve(
                                    const HxBSplineCurve& curve,
                                    double pathInterval, 
                                    HxBSplineSamplingAlg algorithm);

    static HxSampledBSplineCurve makeUniform(HxPolyline2d cp, int degree,
                                    double distance);

    static HxSampledBSplineCurve makeInterpolating(HxPolyline2d cp, double distance);

                                ~HxSampledBSplineCurve();


    int                         ident() const;

    HxBSplineCurve              continuousCurve() const;

    HxBSplineType               curveType() const;

    HxBSplineSamplingAlg        samplingAlg() const;

    int                         nSamples() const;

    double                      sampledT(int j) const;

    vector<double>              allSampledT() const;

    int                         indexOfT(double t) const;

    double                      dT(int j) const;

    HxSampledBSplineInterval    sampledInterval(int j1, int j2) const;

    vector<int>                 samplesAffectedBy(int i) const;

    HxSampledBSplineInterval    intervalAffectedBy(int i) const;

    vector<int>                 PThatAffectSample(int i) const;

    double                      B(int i, int j) const;

    vector<double>              BAll(int j) const;

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

    vector<double>              dBAll(int order, int j) const;

    HxPointR2                   C(int j) const;

    HxPointSetR2                AllC() const;

    HxPolyline2d                CPoly() const;

    HxVectorR2                  dC(int order, int j) const;

    vector<HxVectorR2>          dCAll(int order) const;

    double                      kAtC(int j) const;

    vector<double>              kAtCAll() const;

    double                      dTurnAngleAtC(int j) const;

    vector<double>              dTurnAngleAtCAll() const;

    double                      length() const;

    double                      length(int j1, int j2) const;

    double                      length(const HxSampledBSplineInterval& interval) const;

    int                         closestSample(const HxPointR2& p) const;
 
//
// methods related to control points (do not change sampling itself)
//

    int                         numP() const;

    HxPointSetR2                allP() const;

    HxPolyline2d                controlP() const;

    HxSampledBSplineCurve       changeAllP(const HxPointSetR2& p) const;

    HxSampledBSplineCurve       translateCurve(const HxVectorR2& v, 
                                    const HxSampledBSplineInterval& interval) const;

    STD_OSTREAM&                dump(STD_OSTREAM&) const;

private:
    HxBSplineCurve              _curve;
    HxBSplineSamplingAlg        _samplingAlg;
    vector<double>              _t;     // values of t for all samples
    double                      _dt;    // only uniform sampling! ZZZ
    int                         _ident;

    static int                  _nr;

    void                        makeDefault();
    void                        message( charPtr msg=0 ) const;
    void                        sampleWithResolution( int n );
    void                        sampleWithInterval( double interval );
};


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

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

inline HxBSplineCurve
HxSampledBSplineCurve::continuousCurve() const
{
    return _curve;
}

inline HxBSplineType 
HxSampledBSplineCurve::curveType() const
{
    return _curve.curveType(); 
}

inline int 
HxSampledBSplineCurve::numP() const
{ 
    return _curve.numP();
}

inline HxPointSetR2
HxSampledBSplineCurve::allP() const
{
    return _curve.allP();
}

inline HxPolyline2d
HxSampledBSplineCurve::controlP() const
{
    return HxPolyline2d(allP(), (curveType() == closed));
}

inline HxBSplineSamplingAlg
HxSampledBSplineCurve::samplingAlg() const
{
    return _samplingAlg;
}

inline  int
HxSampledBSplineCurve::nSamples() const
{
    return _t.size();
}

inline  vector<double>
HxSampledBSplineCurve::allSampledT() const
{
    return _t;
}

inline vector<int>
HxSampledBSplineCurve::PThatAffectSample (int i) const
{
    return _curve.PThatAffectCAt(_t[i]);
}

inline  HxSampledBSplineCurve
HxSampledBSplineCurve::changeAllP(const HxPointSetR2& p) const
{
    HxSampledBSplineCurve tmp = *this;
    tmp._curve = _curve.changeAllP(p);
    return tmp;
}

inline double
HxSampledBSplineCurve::B(int i, int j) const
{
    if ( j < 0 || j >= nSamples() ) {
        message("(B) invalid j - setting to 0");
        j = 0;
    }
    return _curve.B( i, _t[j]);
}

inline double
HxSampledBSplineCurve::dT(int j) const
{
    if ( j < 0 || j >= nSamples() ) {
        message("(dT) invalid j - setting to 0");
        j = 0;
    }
    return _dt; // only for uniform!
}

inline double
HxSampledBSplineCurve::dB(int order, int i, int j) const
{
    if ( j < 0 || j >= nSamples() ) {
        message("(B) invalid j - setting to 0");
        j = 0;
    }
    return _curve.dB( order, i, _t[j]);
}

inline HxPointR2
HxSampledBSplineCurve::C(int j) const
{
    if ( j < 0 || j >= nSamples() ) {
        message("(C) invalid j - setting to 0");
        j = 0;
    }
    return _curve.C(_t[j]);
}

inline HxPolyline2d
HxSampledBSplineCurve::CPoly() const
{
    return HxPolyline2d(AllC(), (curveType() == closed));
}

inline HxVectorR2
HxSampledBSplineCurve::dC(int order, int j) const
{
    if ( j < 0 || j >= nSamples() ) {
        message("(C) invalid j - setting to 0");
        j = 0;
    }
    return _curve.dC(order, _t[j]);
}

inline double
HxSampledBSplineCurve::kAtC(int j) const
{
    if ( j < 0 || j >= nSamples() ) {
        message("(kAtC) invalid j - setting to 0");
        j = 0;
    }
    return _curve.kAtC(_t[j]);
}

inline double
HxSampledBSplineCurve::dTurnAngleAtC(int j) const
{
    if ( j < 0 || j >= nSamples() ) {
        message("(dTurnAngleAtC) invalid j - setting to 0");
        j = 0;
    }
    return _curve.dTurnAngleAtC(_t[j]);
}

inline double
HxSampledBSplineCurve::length() const
{
    return _curve.length(nSamples());
}

inline double
HxSampledBSplineCurve::length(int j1, int j2) const
{
    return length( HxSampledBSplineInterval(j1, j2, 
            nSamples(), curveType()) );
}

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

#endif 

---