Smooth Curves from Sharp Points

algorithmsgraphicsfundamentalsfunctional

Picture this: you’re conducting a choir through a gentle glissando while simultaneously waving programmable LEDs during a 30-second exposure. The singers move from discrete pitches—C, E♭, G—while your lights trace waypoints in the darkness. Yet what emerges is seamless: smooth vocal curves and flowing light trails that seem to bend reality.

This magic happens through cubic spline interpolation, a technique that constructs smooth curves from sparse control points. Unlike crude linear interpolation that creates jarring corners, splines ensure your curve passes through every waypoint with continuous, natural-looking derivatives.

10 DIM X(4), Y(4): REM Control points
20 X(1)=0: Y(1)=100: REM Start position
30 X(2)=3: Y(2)=150: REM Peak brightness  
40 X(3)=7: Y(3)=80: REM Valley
50 X(4)=10: Y(4)=200: REM Final flourish
60 FOR T=0 TO 10 STEP 0.5
70 GOSUB 100: REM Calculate spline value
80 PRINT "t=";T;" brightness=";INT(B)
90 NEXT T
100 REM Cubic interpolation subroutine
110 I=1
120 IF I=3 THEN 150
130 IF T<=X(I+1) THEN 150
140 I=I+1: GOTO 120
150 U=(T-X(I))/(X(I+1)-X(I))
160 S=U*U*(3-2*U)
170 B=Y(I)+(Y(I+1)-Y(I))*S
180 RETURN

Haskell approaches this more elegantly, treating splines as composable functions:

spline :: [(Double, Double)] -> Double -> Double
spline points t =
  let ((x0, y0), (x1, y1)) = segment points t
      u = (t - x0) / (x1 - x0)
      smooth = u * u * (3 - 2 * u)
  in y0 + (y1 - y0) * smooth
  where
    segment [p, q] _ = (p, q)
    segment (p:q:rest) t'
      | t' <= fst q = (p, q)
      | otherwise = segment (q:rest) t'
    segment _ _ = error "need at least two points"

-- Generate smooth brightness curve
lightCurve = map (spline [(0,100), (3,150), (7,80), (10,200)]) [0,0.5..10]

The beauty lies in locality: each curve segment depends only on nearby control points, making real-time calculation feasible even on 1980s microcontrollers. Your choir’s pitch trajectory becomes a sequence of cubic polynomials, each ensuring the voice never “breaks” between target frequencies. Similarly, your LED strip interpolates between programmed waypoints, creating those ethereal light ribbons that seem to flow like liquid through the darkness.

Both implementations reveal the same mathematical truth: smooth motion emerges not from infinite precision, but from clever reconstruction between discrete samples. The algorithm trades memory for elegance—storing just the control points while computing infinite intermediate positions on demand.