This is a `playground`

to test code. It runs a full `Node.js`

environment and already has all of `npm`

’s 400,000 packages pre-installed, including `b-spline`

with all `npm`

packages installed. **Try it out**:

var bSpline = require("b-spline")

- all documents on RunKit are public
`require()`

any package directly from npm- use arrow functions, classes, template strings, and most of ES6
`await`

any promise instead of using callbacks (example)- create your own embedded
**node.js**snippets

This service is provided by RunKit and is not affiliated with npm, Inc or the package authors.

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.

```
$ npm install b-spline
```

```
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);
}
```

```
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);
}
```

```
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);
}
```

```
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);
}
```

`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.

- package on npmhttps://npmjs.com/package/b-spline
- licenseMIT

RunKit is a free, in-browser JavaScript dev environment for prototyping **Node.js** code, with every **npm** package installed. Sign up to share your code.

Sign Up for Free