B-splines and NURBS

The formula

A B-spline curve is a weighted blend of control points, where the weights are polynomial "basis" functions built from the Cox-de Boor recursion:

C(u) = Σ N_i,p(u) · P_i          (sum over i = 0 … n)

Reading: the point on the curve at parameter u is a blend of the control points P_i, and each control point's influence is set by its basis function N_i,p(u). p is the polynomial degree (3 for a cubic).

The basis functions come from a recursion. Degree 0 is a step function that is 1 inside its knot interval and 0 outside:

N_i,0(u) = 1  if  u_i ≤ u < u_i+1 ,  else 0

Then you climb the degree ladder, each level built from the two below it:

N_i,p(u) = (u − u_i)/(u_i+p − u_i) · N_i,p−1(u)
         + (u_i+p+1 − u)/(u_i+p+1 − u_i+1) · N_i+1,p−1(u)

Reading: a degree-p basis function is a linear ramp blend of two degree-(p−1) functions. Any 0/0 term is taken as 0. The u_i values form the knot vector — a non-decreasing list that decides where each control point turns on and off.

NURBS adds a weight w_i to every control point and divides through, which is what makes it rational:

              Σ N_i,p(u) · w_i · P_i
C(u)  =  ─────────────────────────────────
              Σ N_i,p(u) · w_i

Reading: each control point is pulled harder when its weight is bigger. The denominator normalizes so the whole thing still sums to 1. That single division is the entire difference between a plain B-spline and a NURBS — and it is the reason NURBS can draw a perfect circle while plain polynomials cannot.

Where you meet it

CAD review at any prime. When you open a model in NX, CATIA, SolidWorks, or Creo and grab a fillet or a lofted surface, you are dragging NURBS control points. The B-rep solid kernel underneath (Parasolid, ACIS) stores every freeform face as a trimmed NURBS surface. Every fairing, duct, and blend radius on a launch vehicle skin is one.
STEP file handoff between contractors. When a subcontractor sends you an AP242 STEP file, the surfaces inside are B-spline and rational B-spline patches. If a face comes across degenerate or wavy, the fix is almost always in the knot vector or a stray weight, not the geometry you can see.
CNC toolpath and CMM inspection. The post-processor walks a NURBS surface to generate cutter locations, and the coordinate measuring machine compares probed points back against that same nominal surface. The deviation report is measured normal to the NURBS.
Font rendering and antenna profiles. Every TrueType glyph is quadratic Bezier segments; PostScript and PDF use cubic Beziers. A shaped reflector or a tapered horn profile handed to the machine shop is often a NURBS spline.

How it works

The whole scheme rests on a few properties that make it behave. Partition of unity: the basis functions sum to exactly 1 at every parameter value, so the curve is a true weighted average of its control points and always stays inside their convex hull. Evaluate a clamped cubic at a scatter of parameters and the basis functions sum to 1.0000000000 every time — that is not decoration, it is what keeps the curve from flying off. One validity limit matters here: the sum-to-1 property, and the curve itself, hold only on the interior span of the knot vector, u_p ≤ u ≤ u_n+1. With a clamped knot vector that interior span is the entire parameter range — one more reason clamped is the CAD default — but with an unclamped or uniform knot vector the basis functions sum to less than 1 near the ends, and the curve there is not a convex combination of the control points at all. There is also an evaluation trap baked into the recursion as written: the half-open degree-0 interval makes every basis function zero at the very last knot, so an implementation must treat the final degree-0 span as closed (u_m−1 ≤ u ≤ u_m), or evaluating at the endpoint returns the origin instead of the end of the curve. Local support: a degree-p basis function is nonzero over only p+1 knot spans, so moving one control point changes only a local stretch of the curve. That locality is why editing a fillet does not ripple across the whole part.

Continuity is set by knot multiplicity. At a simple (single) knot, a degree-p B-spline is continuous through its first p−1 derivatives — a cubic is C² there, curvature-continuous, which is why cubics are the workhorse. Repeat a knot, and you drop one order of continuity for each repeat. Repeat it p times and the curve only stays connected (C⁰) — you get a hard corner on purpose. Clamp both ends by repeating the end knots p+1 times and the curve passes through its first and last control points, which is what makes clamped cubics feel predictable.

Bezier and B-spline are not rivals. A Bezier curve is just a B-spline with no interior knots — one polynomial segment spanning the whole domain, control points blended by Bernstein polynomials. That is why fonts use Beziers (one glyph, a few short segments) and CAD surfaces use B-splines (many segments stitched with guaranteed continuity, no bookkeeping of tangents at every joint).

The rational part is where the payoff and the traps both live. A plain cubic polynomial cannot trace a circle — no polynomial does. But a rational quadratic can. Put three control points at the corner of a square and give the middle point a weight of cos(45°) = √2/2 ≈ 0.7071, and every point of the resulting curve lands exactly on the circle to full floating-point precision. That exactness is the reason Boeing wanted rational splines in the first place: one math form that holds both the freeform fuselage loft and the exact bolt-hole circle, so the kernel never juggles two representations.

The mistakes people make are almost always in the plumbing, not the polynomials. Wrong knot vector length is the classic one — a valid knot vector has exactly (number of control points) + (degree) + 1 entries, and an off-by-one there produces a garbage or crashing curve. Negative or zero weights are the other one: a weight of zero deletes a control point's influence, and a negative weight can push the curve outside its convex hull or make the denominator cross zero, which blows up the division. Weights also are not independent of each other — scaling every weight by the same constant changes nothing, because the ratio is all that matters. And a NURBS "circle" is only a circle if the weights are right; a modeler that fits a spline through sampled points gives you a curve that looks round and is off by microns, which a CMM will happily flag.

History

The story starts in the French auto industry in the late 1950s, when two engineers solved the same problem without knowing about each other. Paul de Casteljau, at Citroën, worked out a numerically stable recursive way to build smooth curves from control points — the algorithm that still carries his name — but Citroën kept it a trade secret and published nothing for years ^[1]^[2]. Pierre Bézier, at Renault, developed an equivalent construction through the 1960s for the UNISURF system that shaped Renault's car bodies, and because Renault let him publish, the curves ended up called Bézier curves ^[1]^[2].

The deeper mathematics was already older. Isaac Schoenberg, working on approximating data with smooth functions, laid the groundwork in a 1946 paper in the Quarterly of Applied Mathematics and is credited with the name "B-spline," short for basis spline ^[3]^[4]. The practical recursion that every kernel now uses was published independently in 1972 by Carl de Boor and by M.G. Cox — the Cox-de Boor recursion, a generalization of de Casteljau's idea to arbitrary knot spacing ^[3]^[5].

The last piece was making it rational. Richard Riesenfeld brought B-splines into geometric design in his 1973 Syracuse University dissertation, and Ken Versprille — a student of Steven Coons in the same Syracuse research group — generalized them to the non-uniform rational form in his 1975 PhD thesis, "Computer-Aided Design Applications of the Rational B-Spline Approximation Form" ^[1]^[7]. Boeing, hunting for a single math form that could hold both their freeform aircraft surfaces and exact conics, adopted it, coined the acronym NURBS — by Versprille's own account, a Boeing manager got tired of pronouncing the full name ^[6]^[7] — and proposed it into the IGES data-exchange standard in August 1981 ^[8]. From there it spread into every CAD kernel and every exchange standard — IGES, STEP, ACIS — and by 1989 Silicon Graphics was rendering NURBS in real time on the desktop ^[6].

Related tools

/tools/beam-deflection
/tools/moment-of-inertia-shapes
/tools/section-modulus-rect
/tools/convert-length
/tools/convert-angle

Sources

Written by HE in our own words from the cited sources — engineering judgment included, your stamp still required. All entries →