I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# B-spline

B-spline is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Generate a B-spline curve with a list of 12 points and plot or save image.

Coordinates of control points:

```   start=171,171
1 185,111,
2 202,109,
3 202,189
4 328,160
5 208,254
6 241,330
7 164,252
8 69,278
9 139,208
10 72,148
end=168,172
```

Rules!!!!

Do not use third party libraries or functions

## Julia

Choose BSpline D of 2, ie degree 1.

`using Graphics, Plots Point(t::Tuple) = Vec2(Float64(t), Float64(t))const controlpoints = Point.([(171, 171), (185, 111), (202, 109), (202, 189), (328, 160),    (208, 254), (241, 330), (164,252), (69, 278), (139, 208), (72, 148), (168, 172)])plt = plot(map(a -> a.x, controlpoints), map(a -> a.y, controlpoints))savefig(plt, "BSplineplot.png")`

## Mathematica/Wolfram Language

`Graphics[ BSplineCurve[{{171, 171}, {185, 111}, {202, 109}, {202, 189}, {328,     160}, {208, 254}, {241, 330}, {164, 252}, {69, 278}, {139,     208}, {72, 148}, {168, 172}}, SplineClosed -> True,   SplineDegree -> 2]]`
Output:

Outputs a graphical representation of a B-spline.

## Wren

Library: DOME

In the absence of any clarification on what to use (see Talk page), the following uses a degree of 3 (i.e order k = 4) and a uniform knot vector from 1 to 16 (as there are 12 control points) with a delta of 1.

If one uses a value for k of 1, then the script will simply plot the control points as in the Julia example.

`import "dome" for Window, Processimport "graphics" for Canvas, Color class BSpline {    construct new(width, height, cpoints, k) {        Window.resize(width, height)        Canvas.resize(width, height)        Window.title = "B-spline curve"        _p = cpoints        _n = cpoints.count - 1        _k = k        _t = (1.._n + 1 + k).toList // use a uniform knot vector, delta = 1    }     // B-spline helper function    w(i, k, x) { (_t[i+k] != _t[i]) ? (x - _t[i]) / (_t[i+k] - _t[i]) : 0 }     // B-spline function    b(i, k, x) {        if (k == 1) return (_t[i] <= x  &&  x < _t[i + 1]) ? 1 : 0        return w(i, k-1, x) * b(i, k-1, x) + (1 - w(i+1, k-1, x)) * b(i+1, k-1, x)    }     // B-spline points    p() {        var bpoints = []        for (x in _t[_k-1]..._t[_n + 1]) {            var sumX = 0            var sumY = 0            for (i in 0.._n) {                var f = b(i, _k, x)                sumX = sumX + f * _p[i]                sumY = sumY + f * _p[i]            }            bpoints.add([sumX.round, sumY.round])         }         return bpoints    }     init() {        if (_k > _n + 1 || _k < 1) {            System.print("k (= %(_k)) can't be more than %(_n+1) or less than 1.")            Process.exit()        }        var bpoints = p()        // plot the curve        for (i in 1...bpoints.count) {            Canvas.line(bpoints[i-1], bpoints[i-1], bpoints[i], bpoints[i], Color.white)        }    }     update() {}     draw(alpha) {}} var cpoints = [    [171, 171], [185, 111], [202, 109], [202, 189], [328, 160], [208, 254],    [241, 330], [164, 252], [ 69, 278], [139, 208], [ 72, 148], [168, 172]]var k = 4 // polynomial degree is one less than this i.e. cubicvar Game = BSpline.new(400, 400, cpoints, k)`