|| ||           || Doxygen's  

---

HxBSplineInterval.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 HxBSplineInterval_h
#define HxBSplineInterval_h

#include <utility>
using std::pair;

#include "HxStd.h"
#include "HxUtilityMath.h"
#include "HxBSplineType.h"


class HxBSplineInterval : pair<double,double> {
public:
                        HxBSplineInterval();

                        HxBSplineInterval(double b, double e, 
                                          double min, double max, 
                                          HxBSplineType type );

                        HxBSplineInterval(double b, double e, 
                                          double min, double max, 
                                          int closed );

                        ~HxBSplineInterval();


    double              begin() const;

    double              end() const;

    int                 contains(double t) const;

    double              next(double t, double delta) const;

    double              prev(double t, double delta) const;

    double              length() const;

    double              middle() const;

    double              ratio(double r) const;

    int                 isClosed() const;
    
    HxBSplineInterval   cropBegin(double t) const;

    HxBSplineInterval   cropEnd(double t) const;

    HxBSplineInterval   part(double t1, double t2) const;

private:
    double      _min;   // min of total path (for wrapping)
    double      _max;   // max of total path (for wrapping)
    int         _wrap;  // flag for closed interval
};


inline 
HxBSplineInterval::HxBSplineInterval() : pair<double,double>() 
{
    _min = 0;
    _max = 0;
    _wrap = 0;
}

inline 
HxBSplineInterval::HxBSplineInterval(double b, double e, 
    double min, double max, HxBSplineType type) 
    : pair<double,double>(b,e) 
{
    _min = min;
    _max = max;
    _wrap = (type == closed);
}

inline 
HxBSplineInterval::HxBSplineInterval(double b, double e, 
    double min, double max, int wrap) 
    : pair<double,double>(b,e) 
{
    _min = min;
    _max = max;
    _wrap = wrap;
}

inline 
HxBSplineInterval::~HxBSplineInterval() 
{
}

inline double
HxBSplineInterval::begin() const
{
    return first;
}

inline double
HxBSplineInterval::end() const
{
    return second;
}

inline int
HxBSplineInterval::contains(double t) const
{
    if ( first == second )      // special case?
        return (t >= _min && t < _max);
    if ( first > second )       // is wrapped?
        return (t >= first && t < _max) || (t >= _min && t < second);
    else    return (t >= first && t < second);
}

inline double
HxBSplineInterval::next(double t, double delta ) const
{
    t += delta;
    if ( t >= _max && _wrap )
        t = _min + (t - _max);
    return t;
}

inline double
HxBSplineInterval::prev(double t, double delta ) const
{
    t -= delta;
    if ( t <  _min && _wrap )
        t = _max - (_min - t);
    return t;
}

inline double
HxBSplineInterval::length() const
{
    double tmp = second - first;
    if ( tmp < 0 && _wrap ) 
        return (_max - EPS - first) + (second - _min);
    else    if ( tmp < EPS )
            return EPS;
        else    return tmp - EPS;
}

inline double
HxBSplineInterval::middle() const
{
    return ratio(0.5);
}

inline double
HxBSplineInterval::ratio(double r) const
{
    double t = length() * r + first;
    if ( t >= _max )
        t = _min + (t - _max);
    return t;
}

inline int
HxBSplineInterval::isClosed() const
{
    return _wrap;
}

inline HxBSplineInterval
HxBSplineInterval::cropBegin(double t) const
{
    HxBSplineInterval tmp(t, second, _min, _max, _wrap);
    return tmp;
}

inline HxBSplineInterval
HxBSplineInterval::cropEnd(double t) const
{
    HxBSplineInterval tmp(first, t, _min, _max, _wrap);
    return tmp;
}

inline HxBSplineInterval
HxBSplineInterval::part(double t1, double t2) const
{
    HxBSplineInterval tmp(t1, t2, _min, _max, closed);
    tmp._wrap = _wrap;
    return tmp;
}

#endif 

---