101 lines
3.9 KiB
C++
101 lines
3.9 KiB
C++
#ifndef HGL_GRAPH_SPLINE_INCLUDE
|
|
#define HGL_GRAPH_SPLINE_INCLUDE
|
|
|
|
#include<hgl/math/Vector.h>
|
|
#include<vector>
|
|
|
|
namespace hgl
|
|
{
|
|
namespace graph
|
|
{
|
|
enum class SplineNode
|
|
{
|
|
UNIFORM,
|
|
OPEN_UNIFORM ///< Connected to the first and last control points
|
|
};
|
|
|
|
template<typename Point_t, typename Real_t> class Spline
|
|
{
|
|
public:
|
|
|
|
/// Type of the nodal vector
|
|
/// @param k : order of the spline (minimum is two)
|
|
/// @param node_type : nodal vector type (uniform, open_uniform)
|
|
/// This will define the behavior of the spline with its control points
|
|
/// as well as its speed according to its parameter.
|
|
Spline(int k = 2, SplineNode node_type = SplineNode::OPEN_UNIFORM);
|
|
|
|
/// Set the position of the spline control points.
|
|
void set_ctrl_points(const std::vector<Point_t>& point);
|
|
|
|
/// Get the control points of the spline
|
|
void get_ctrl_points(std::vector<Point_t>& points) const;
|
|
|
|
/// The the nodal vector type
|
|
void set_node_type( SplineNode type);
|
|
|
|
/// Evaluate position of the spline
|
|
/// @param u : curve parameter ranging from [0; 1]
|
|
Point_t eval_f(Real_t u) const;
|
|
|
|
/// Evaluate speed of the spline
|
|
Point_t eval_df(Real_t u) const;
|
|
|
|
int get_order() const { return _k; }
|
|
|
|
private:
|
|
// -------------------------------------------------------------------------
|
|
/// @name Class tools
|
|
// -------------------------------------------------------------------------
|
|
|
|
void assert_splines() const;
|
|
|
|
/// set value and size of the nodal vector depending on the current number
|
|
/// of control points
|
|
void set_nodal_vector();
|
|
|
|
/// Set values of the nodal vector to be uniform
|
|
void set_node_to_uniform();
|
|
|
|
/// Set values of the nodal vector to be open uniform
|
|
void set_node_to_open_uniform();
|
|
|
|
/// Evaluate the equation of a splines using the blossom algorithm
|
|
/// @param u : the curve parameter which range from the values
|
|
/// [node[k-1]; node[point.size()]]
|
|
/// @param point : the control points which size must be at least equal to
|
|
/// the order of the spline (point.size() >= k)
|
|
/// @param k : the spline order (degree == k-1)
|
|
/// @param node : the nodal vector which defines the speed of the spline
|
|
/// parameter u. The nodal vector size must be equal to (k + point.size())
|
|
/// @param off : offset to apply to the nodal vector 'node' before reading
|
|
/// from it. this is useful to compute derivatives.
|
|
Point_t eval(Real_t u,
|
|
const std::vector<Point_t>& point,
|
|
int k,
|
|
const std::vector<Real_t>& node,
|
|
int off = 0) const;
|
|
|
|
Point_t eval_rec(Real_t u,
|
|
std::vector<Point_t> p_in,
|
|
int k,
|
|
std::vector<Real_t> node_in) const;
|
|
|
|
// -------------------------------------------------------------------------
|
|
/// @name attributes
|
|
// -------------------------------------------------------------------------
|
|
|
|
SplineNode _node_type; ///< Nodal vector type
|
|
int _k; ///< spline order
|
|
std::vector<Point_t> _point; ///< Control points
|
|
std::vector<Point_t> _vec; ///< Control points differences
|
|
std::vector<Real_t> _node; ///< Nodal vector
|
|
};//class Spline
|
|
|
|
using Spline2f=Spline<Vector2f,float>;
|
|
using Spline3f=Spline<Vector3f,float>;
|
|
}//namespace graph
|
|
}//namespace hgl
|
|
#include<hgl/graph/Spline.cpp>
|
|
#endif//HGL_GRAPH_SPLINE_INCLUDE
|