# thibauts/b-spline

B-spline interpolation
Latest commit fdc3a31 Jul 24, 2016
Type Name Latest commit message Commit time
Failed to load latest commit information.
test Jul 24, 2016
.gitignore Jul 21, 2016
index.js Jul 10, 2016
package.json Jul 24, 2016

# b-spline

### B-spline interpolation

B-spline interpolation of control points of any dimensionality using de Boor's algorithm.

The interpolator can take an optional weight vector, making the resulting curve a Non-Uniform Rational B-Spline (NURBS) curve if you wish so.

The knot vector is optional too, and when not provided an unclamped uniform knot vector will be generated internally.

## Install

`\$ npm install b-spline`

## Examples

#### Unclamped knot vector

```var bspline = require('b-spline');

var points = [
[-1.0,  0.0],
[-0.5,  0.5],
[ 0.5, -0.5],
[ 1.0,  0.0]
];

var degree = 2;

// As we don't provide a knot vector, one will be generated
// internally and have the following form :
//
// var knots = [0, 1, 2, 3, 4, 5, 6];
//
// Knot vectors must have `number of points + degree + 1` knots.
// Here we have 4 points and the degree is 2, so the knot vector
// length will be 7.
//
// This knot vector is called "uniform" as the knots are all spaced uniformly,
// ie. the knot spans are all equal (here 1).

for(var t=0; t<1; t+=0.01) {
var point = bspline(t, degree, points);
}```

#### Clamped knot vector

```var bspline = require('b-spline');

var points = [
[-1.0,  0.0],
[-0.5,  0.5],
[ 0.5, -0.5],
[ 1.0,  0.0]
];

var degree = 2;

// B-splines with clamped knot vectors pass through
// the two end control points.
//
// A clamped knot vector must have `degree + 1` equal knots
// at both its beginning and end.

var knots = [
0, 0, 0, 1, 2, 2, 2
];

for(var t=0; t<1; t+=0.01) {
var point = bspline(t, degree, points, knots);
}```

#### Closed curves

```var bspline = require('b-spline');

// Closed curves are built by repeating the `degree + 1` first
// control points at the end of the curve

var points = [
[-1.0,  0.0],
[-0.5,  0.5],
[ 0.5, -0.5],
[ 1.0,  0.0],

[-1.0,  0.0],
[-0.5,  0.5],
[ 0.5, -0.5]
];

var degree = 2;

// and using an unclamped knot vector

var knots = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
];

for(var t=0; t<1; t+=0.01) {
var point = bspline(t, degree, points, knots);
}```

#### Non-uniform rational

```var bspline = require('b-spline');

var points = [
[ 0.0, -0.5],
[-0.5, -0.5],

[-0.5,  0.0],
[-0.5,  0.5],

[ 0.0,  0.5],
[ 0.5,  0.5],

[ 0.5,  0.0],
[ 0.5, -0.5],
[ 0.0, -0.5]  // P0
]

// Here the curve is called non-uniform as the knots
// are not equally spaced

var knots = [
0, 0, 0, 1/4, 1/4, 1/2, 1/2, 3/4, 3/4, 1, 1, 1
];

var w = Math.pow(2, 0.5) / 2;

// and rational as its control points have varying weights

var weights = [
1, w, 1, w, 1, w, 1, w, 1
]

var degree = 2;

for(var t=0; t<1; t+=0.01) {
var point = bspline(t, degree, points, knots, weights);
}```

## Usage

### `bspline(t, degree, points[, knots, weights])`

• `t` position along the curve in the [0, 1] range
• `degree` degree of the curve. Must be less than or equal to the number of control points minus 1. 1 is linear, 2 is quadratic, 3 is cubic, and so on.
• `points` control points that will be interpolated. Can be vectors of any dimensionality (`[x, y]`, `[x, y, z]`, ...)
• `knots` optional knot vector. Allow to modulate the control points interpolation spans on `t`. Must be a non-decreasing sequence of `number of points + degree + 1` length values.
• `weights` optional control points weights. Must be the same length as the control point array.
You can’t perform that action at this time.