In class I started by pointing out that you can make arbitrarily complex - but controllable - smooth curves by stringing together parametric cubic spline curves end to end, as long as you make sure that the derivatives of successive spline curves match where they join.

In any given dimension, the value of a parametric cubic spline is given by the vector C of coefficients [a,b,c,d]:

f(t) = a t³ + b t² + c t + d

So if you wanted to make a two dimensional parametric cubic spline, to define a path on the (x,y) plane, you would use two of these functions:

x(t) = a_x t³ + b_x t² + c_x t + d
y(t) = a_y t³ + b_y t² + c_y t + d

Generally we can split the right side of the above equations into two parts, the coefficient vector C = [a,b,c,d] and the cubic parameter vector T = [t³,t²,t,1], because we're really just doing an inner (dot) product between those two vectors. For example, we can express the last two equations as:

x(t) = C_x • T
y(t) = C_y • T

In this form it's easy to evaluate splines. For example, let's say you're doing an animation, and you want to animate a value (eg: the angle of a swinging arm) from time time₁ to time₂. If you have the four spline coefficients C = [a,b,c,d] for that segment of the animation, then at any moment in time you just need to evaluate the cubic spline function based on the fraction of time that has elapsed between time₁ and time₂:

t = (time - time₁) / (time₂ - time₁)
T = [t³,t²,t,1]
f(t) = C • T

Similarly, if you want to draw a cubic curve, and you have the coefficient vectors C_x and C_y, then you can do something like this (in pseudocode):

for (t = 0 ; t < 1 ; t += ε) {
      T₀ = [t³,t²,t,1]
      T₁ = [(t+&epsilon)³, (t+&epsilon)², t+&epsilon, 1]
      drawLine ( C_x•T₀ , C_y•T₀ , C_x•T₁ , C_y•T₁ )
}

Of course, as we said in class, it is not really intuitive for humans to build nice looking cubic curves as weighted sums of the primitive functions t³, t², t and 1. So we generally want to design parametric cubic spline curves not in the space C, but rather in some more convenient space of coefficients G, which would allow us to use more intuitive curve shapes.

Hermite splines:

For example, if we want to specify a function value at the beginning and at the end (of the spline curve, as well as a function derivative at the beginning and the end of the spline curve, then we are working with Hermite splines. By convention, we refer to the beginning and end points as P1 and P4, respectively, and we refer to their derivatives as as R1 and R4, respectively.

This allows us to work with the four intuitive curve primitives:

2t3-3t2+1	-2t3+3t2	t3-2t2+t	t3-t2

• P1 = value at t=0
• P4 = value at t=1
• R1 = derivative at t=0
• R4 = derivative at t=1

To do our inner loop computations, we need to convert this geometry description G = [P1,P4,R1,R4] to a cubic coefficients description C = [a,b,c,d].

In other words, we need to transform function coordinate systems:

To do this, we just use the Hermite matrix:

Note that the columns of the Hermite matrix are just the coefficients of the geometric functions (you can see this from the parts highlighted in red above).

Bezier splines and B-Splines:

We also briefly touched on Bezier splines and B-Splines, which are different ways of presenting parametric cubic splines to a user. In the next class we will go over these in more detail.