G3D::SplineBase Class Reference

#include <Spline.h>

Public Member Functions
	SplineBase ()
virtual	~SplineBase ()
float	getFinalInterval () const
float	duration () const
void	computeIndex (float s, int &i, float &u) const

Static Public Member Functions
static Matrix4	computeBasis ()

Public Attributes
Array< float >	time
SplineExtrapolationMode	extrapolationMode
float	finalInterval
SplineInterpolationMode	interpolationMode

Protected Member Functions
void	computeIndexInBounds (float s, int &i, float &u) const

Detailed Description

Common implementation code for all G3D::Spline template parameters

Constructor & Destructor Documentation

G3D::SplineBase::SplineBase ( )

inline

 : 
 extrapolationMode(SplineExtrapolationMode::CYCLIC), 
 finalInterval(-1), 
 interpolationMode(SplineInterpolationMode::CUBIC) {}

virtual G3D::SplineBase::~SplineBase ( )

inlinevirtual

{}

Member Function Documentation

Matrix4 G3D::SplineBase::computeBasis ( )

static

Computes the derivative spline basis from the control point version.

 {
 // The standard Catmull-Rom spline basis (e.g., Watt & Watt p108)
 // is for [u^3 u^2 u^1 u^0] * B * [p[0] p[1] p[2] p[3]]^T.
 // We need a basis formed for:
 //
 // U * C * [2*p'[1] p[1] p[2] 2*p'[2]]^T 
 //
 // U * C * [p2-p0 p1 p2 p3-p1]^T 
 //
 // To make this transformation, compute the differences of columns in C:
 // For [p0 p1 p2 p3]
 Matrix4 basis =
 Matrix4( -1, 3, -3, 1,
 2, -5, 4, -1,
 -1, 0, 1, 0,
 0, 2, 0, 0) * 0.5f;

 // For [-p0 p1 p2 p3]^T 
 basis.setColumn(0, -basis.column(0));

 // For [-p0 p1 p2 p3-p1]^T 
 basis.setColumn(1, basis.column(1) + basis.column(3));

 // For [p2-p0 p1 p2 p3-p1]^T 
 basis.setColumn(2, basis.column(2) - basis.column(0));

 return basis;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::SplineBase::computeIndex	(	float	s,
		int &	i,
		float &	u
	)		const

Given a time s, finds i and 0 <= u < 1 such that s = time[i] * u + time[i + 1] * (1 - u). Note that i may be outside the bounds of the time and control arrays; use getControl to handle wraparound and extrapolation issues.

This function takes expected O(1) time for control points with uniform time sampled control points or for uniformly distributed random time samples, but may take O( log time.size() ) time in the worst case.

Called from evaluate().

 {
 int N = time.size();
 debugAssertM(N > 0, "No control points");
 float t0 = time[0];
 float tn = time[N - 1];
 
 if (N < 2) {
 // No control points to work with
 i = 0;
 u = 0.0;
 } else if (extrapolationMode == SplineExtrapolationMode::CYCLIC) {
 float fi = getFinalInterval();
 
 // Cyclic spline
 if ((s < t0) || (s >= tn + fi)) {
 // Cyclic, off the bottom or top
 
 // Compute offset and reduce to the in-bounds case

 float d = duration();
 // Number of times we wrapped around the cyclic array
 int wraps = iFloor((s - t0) / d);
 
 debugAssert(s - d * wraps >= t0);
 debugAssert(s - d * wraps < tn + getFinalInterval());

 computeIndex(s - d * wraps, i, u);
 i += wraps * N;
 
 } else if (s >= tn) {
 debugAssert(s < tn + fi);
 // Cyclic, off the top but before the end of the last interval
 i = N - 1;
 u = (s - tn) / fi;
 
 } else {
 // Cyclic, in bounds
 computeIndexInBounds(s, i, u);
 }
 
 } else {
 // Non-cyclic
 
 if (s < t0) {
 // Non-cyclic, off the bottom. Assume points are spaced
 // following the first time interval.
 
 float dt = time[1] - t0;
 float x = (s - t0) / dt;
 i = iFloor(x);
 u = x - i;
 
 } else if (s >= tn) {
 // Non-cyclic, off the top. Assume points are spaced following
 // the last time interval.
 
 float dt = tn - time[N - 2];
 float x = N - 1 + (s - tn) / dt;
 i = iFloor(x);
 u = x - i; 
 
 } else {
 // In bounds, non-cyclic. Assume a regular
 // distribution (which gives O(1) for uniform spacing)
 // and then binary search to handle the general case
 // efficiently.
 computeIndexInBounds(s, i, u);
 
 } // if in bounds
 } // extrapolation Mode
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::SplineBase::computeIndexInBounds ( float  s, int &  i, float &  u  ) const

protected

Assumes that t0 <= s < tn. called by computeIndex.

 {
 int N = time.size();
 float t0 = time[0];
 float tn = time[N - 1];
 
 i = iFloor((N - 1) * (s - t0) / (tn - t0));
 
 // Inclusive bounds for binary search
 int hi = N - 1;
 int lo = 0;
 
 while ((time[i] > s) || (time[i + 1] <= s)) {
 
 if (time[i] > s) {
 // too big
 hi = i - 1;
 } else if (time[i + 1] <= s) {
 // too small
 lo = i + 1;
 }
 
 i = (hi + lo) / 2;
 }
 
 // Having exited the above loop, i must be correct, so compute u.
 u = (s - time[i]) / (time[i + 1] - time[i]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::SplineBase::duration

(

)

const

Returns the amount of time covered by this spline in one period. For a cyclic spline, this contains the final interval.

 {
 if (time.size() == 0) {
 return 0;
 } else {
 return time.last() - time[0] + getFinalInterval();
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::SplineBase::getFinalInterval

(

)

const

See specification for Spline::finalInterval; this handles the non-positive case. Returns 0 if not cyclic.

 {
 if (extrapolationMode != SplineExtrapolationMode::CYCLIC) {
 return 0;
 } else if (finalInterval <= 0) {
 int N = time.size();
 if (N >= 2) {
 return (time[1] - time[0] + time[N - 1] - time[N - 2]) * 0.5f;
 } else {
 return 1.0f;
 }
 } else {
 return finalInterval;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

SplineExtrapolationMode G3D::SplineBase::extrapolationMode

If CYCLIC, then the control points will be assumed to wrap around. If LINEAR, then the tangents at the ends of the spline point to the final control points. If CONSTANT, the end control points will be treated as multiple contol points (so the value remains constant at the ends)

float G3D::SplineBase::finalInterval

For a cyclic spline, this is the time elapsed between the last control point and the first. If less than or equal to zero this is assumed to be:

(time[0] - time[1] + . time[time.size() - 1] - time[time.size() - 2]) / 2.

SplineInterpolationMode G3D::SplineBase::interpolationMode

Array<float> G3D::SplineBase::time

Times at which control points occur. Must have the same number of elements as Spline::control.

---

The documentation for this class was generated from the following files:

• dep/g3dlite/include/G3D/Spline.h
• dep/g3dlite/source/SplineBase.cpp