bezier_curve.h 2.55 KB
Newer Older
1
/**
2
* \file bezier_curve.h
3
4
5
6
7
8
9
10
11
12
* \brief class allowing to create a Bezier curve of dimension 1 <= n <= 3.
* \author Steve T.
* \version 0.1
* \date 06/17/2013
*/


#ifndef _CLASS_BEZIERCURVE
#define _CLASS_BEZIERCURVE

stonneau's avatar
stonneau committed
13
#include "curve_abc.h"
14
15
16
17
18
19
20

#include "MathDefs.h"

#include <vector>

namespace spline
{
21
22
23
/// \class BezierCurve
/// \brief Represents a curve
///
24
template<typename Time= double, typename Numeric=Time, std::size_t Dim=3, bool Safe=false
25
26
27
28
29
30
31
, typename Point= Eigen::Matrix<Numeric, Dim, 1> >
struct bezier_curve : public  curve_abc<Time, Numeric, Dim, Safe, Point>
{
	typedef Point 	point_t;
	typedef Time 	time_t;
	typedef Numeric	num_t;

32
33
/* Constructors - destructors */
	public:
34
35
36
37
	///\brief Constructor
	///\param PointsBegin, PointsEnd : the points parametering the Bezier curve
	///\TODO : so far size above 3 is ignored
	template<typename In>
stonneau's avatar
stonneau committed
38
	bezier_curve(In PointsBegin, In PointsEnd, const time_t minBound=0, const time_t maxBound=1)
39
40
41
42
43
44
45
46
47
48
49
50
51
52
	: minBound_(minBound)
	, maxBound_(maxBound)
	, size_(std::distance(PointsBegin, PointsEnd))
	{
		In it(PointsBegin);
		if(Safe && (size_<=1 || minBound == maxBound))
		{
			throw; // TODO 
		}
		for(; it != PointsEnd; ++it)
		{
			pts_.push_back(*it);
		}
	}
53

54
	///\brief Destructor
stonneau's avatar
stonneau committed
55
	~bezier_curve()
56
57
58
	{
		// NOTHING
	}
59
60

	private:
61
62
	bezier_curve(const bezier_curve&);
	bezier_curve& operator=(const bezier_curve&);
63
64
65
66
67
68
/* Constructors - destructors */

/*Operations*/
	public:
	///  \brief Evaluation of the cubic spline at time t.
	///  \param t : the time when to evaluate the spine
69
	///  \param return : the value x(t)
stonneau's avatar
stonneau committed
70
	virtual point_t operator()(time_t t) const
71
72
73
74
	{
		num_t nT = (t - minBound_) / (maxBound_ - minBound_);
		if(Safe &! (0 <= nT && nT <= 1))
		{
75
			//throw; // TODO
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
		}
		else
		{
			num_t dt = (1 - nT);
			switch(size_)
			{	
				case 2 :
					return pts_[0] * dt +  nT * pts_[1];
				break;
				case 3 :
					return 	pts_[0] * dt * dt 
                       				+ 2 * pts_[1] * nT * dt
						+ pts_[2] * nT * nT;
				break;
				default :
					return 	pts_[0] * dt * dt * dt
						+ 3 * pts_[1] * nT * dt * dt 
						+ 3 * pts_[2] * nT * nT * dt 
						+ pts_[3] * nT * nT *nT;
				break;
			}
		}
	}
99
/*Operations*/
100
101

/*Helpers*/
stonneau's avatar
stonneau committed
102
103
	virtual time_t min() const{return minBound_;}
	virtual time_t max() const{return maxBound_;}
104
105
106
/*Helpers*/

	public:
107
108
	const int size_;
	const time_t minBound_, maxBound_;
109
110
	
	private:
111
112
113
	typedef std::vector<Point,Eigen::aligned_allocator<Point> > T_Vector;
	T_Vector  pts_;
};
114
115
116
}
#endif //_CLASS_BEZIERCURVE