void SplineInterpolate(const vector<Vector>& pts,const vector<Real>& times,
GeneralizedCubicBezierSpline& path,
CSpace* space,GeodesicManifold* manifold)
{
SplineInterpolate(pts,times,path.segments,space,manifold);
Assert(path.segments.size()+1==times.size());
path.durations.resize(path.segments.size());
for(size_t i=0;i<path.segments.size();i++) path.durations[i] = times[i+1]-times[i];
}
void SplineInterpolate(const vector<Vector>& pts,
GeneralizedCubicBezierSpline& path,
CSpace* space,GeodesicManifold* manifold,
Real coxDeBoorParameter)
{
if(coxDeBoorParameter == 0) {
//uniform
SplineInterpolate(pts,path.segments,space,manifold);
path.durations.resize(path.segments.size());
fill(path.durations.begin(),path.durations.end(),1);
}
else {
vector<Real> times(pts.size());
times[0] = 0;
path.durations.resize(pts.size()-1);
for(size_t i=0;i+1<pts.size();i++) {
path.durations[i] = Pow(pts[i].distance(pts[i+1]),coxDeBoorParameter);
times[i+1] = times[i] + path.durations[i];
}
SplineInterpolate(pts,times,path.segments,space,manifold);
}
}
void GeneratePerlinPlasma(PixBufT *pixbuf, size_t step, int32_t *random) {
size_t size = pixbuf->height / step;
size_t x, y, i;
SplineT *colors = NewSpline(size, TRUE);
for (x = 0; x < pixbuf->width; x += step) {
void PutDataColumn(PixBufT *pixbuf, size_t index, float *value) {
PutPixel(pixbuf, x, index * step * pixbuf->width, (uint8_t)*value);
}
for (i = 0; i < size; i++)
colors->knots[i].value = RandomFloat(random) * 255.0f;
SplineAttachCatmullRomTangents(colors);
SplineInterpolate(colors, step, pixbuf, (SetItemFuncT)PutDataColumn);
}
bool InterpolateAndTimeOptimize(const vector<Config>& configs,
GeodesicManifold* space,
VectorFieldFunction* constraint,
Real constraintTolerance,
const Vector& vmin,const Vector& vmax,
const Vector& amin,const Vector& amax,
TimeScaledBezierCurve& output)
{
if(constraint) {
SmoothConstrainedInterpolator interp(space,constraint);
interp.xtol = constraintTolerance;
if(!MultiSmoothInterpolate(interp,configs,output.path)) return false;
}
else {
GeneralizedCubicBezierSpline path;
SplineInterpolate(configs,path.segments,space);
path.durations.resize(path.segments.size());
for(size_t i=0;i+1<path.segments.size();i++)
path.durations[i] = 1.0/path.durations.size();
//treat constraintTolerance as a resolution, discretize the curves into
//n pieces
int n=(int)Ceil(1.0/constraintTolerance);
output.path.segments.resize(n);
output.path.durations.resize(n);
Config xp,vp,xn,vn;
path.Eval(0,xp);
path.Deriv(0,vp);
for(int i=0;i<n;i++) {
Real u2=Real(i+1)/Real(n);
path.Eval(u2,xn);
path.Deriv(u2,vn);
output.path.segments[i].x0 = xp;
output.path.segments[i].x3 = xn;
output.path.segments[i].SetNaturalTangents(vp,vn);
output.path.durations[i] = 1.0/Real(n);
}
swap(xp,xn);
swap(vp,vn);
}
if(!output.OptimizeTimeScaling(vmin,vmax,amin,amax)) return false;
return true;
}
void SmoothPoints( const PointArray& inPts, PointArray& outPts, unsigned int N )
{
if( inPts.empty() ) return;
SplineInterpolate( inPts, outPts, N );
}
