In a moment, I’ll point you to a separate
website hosting a short sequence of what we’re calling “explorable videos”. It was done in collaboration with Ben Eater,
who runs an excellent channel about Computer Engineering which viewers of this channel
would definitely enjoy, and all the web development that made these explorable videos possible
is thanks to him. I don’t want to say too much about it now,
it’s really something that you have to experience for yourself. Certainly one of the coolest things I’ve
had the pleasure of working on. So to set the stage, last video I described
quaternions, a certain 4-dimensional number system that the 19th-century versions of Wolverine
and the old man from Home Alone called “evil” for how convoluted it seemed at the time. And perhaps you too are wondering why on earth
anyone would bother with such an alien-seeming number system.
One of the big reasons, especially for programmers,
is that they give a really nice way for describing a 3d orientation which is not susceptible
to the bugs and edge-cases of other methods. I mean, they’re interesting mathematically
for a lot of reasons, but this is probably their biggest practical application. To take one example, a friend of mine who
used to work at Apple, Andy Matuschak, delighted in telling me about shipping code to hundreds
of millions of devices that uses quaternions to track the phone’s model for how it’s
oriented in space.
That’s right, your phone almost certainly
has software running inside it that rely on quaternions. The thing is, there are other ways to think
about and compute rotations, many of which are way simpler to think about than quaternions. For example, any of you familiar with linear
algebra will know that 3×3 matrices can really nicely describe 3d orientation, and a common
way many programmers like to think about constructing one of these matrices for a desired orientation
is to imagine rotating an object around three easy-to-think-about axes, where the relevant
angles for these rotations are commonly called “Euler angles”. This mostly works, but one big problem is
that it’s vulnerable to is something called “gimbal lock”, where two of your axes
of rotation get lined up and you lose a degree of freedom. It can also cause difficulties when trying
to interpolate between two orientations.
There are many great resources online for
learning about Euler angles and Gimbal lock, and I’ve left links in the description to
a few. Not only do quaternions avoid issues like
gimbal lock, they give a very seamless way to interpolate between two three-dimensional
orientations, one which lacks ambiguities of Euler angles, and which avoids the issues
of numerical precision and normalization that arise in trying to interpolate between two
rotation matrices. To warm up to the idea of how multiplication
in some higher dimensional number system might be used to compute rotations, take a moment
to remember how complex numbers give a slick method for computing 2d rotations.
Specifically, let’s say you have some point
in 2d space, like (4, 1), and you want to know the new coordinates you’d get after
rotating it 30 degrees. Complex numbers give sort of a snazzy way
to do this: Take the complex number 30 degrees off the horizontal, a distance 1 from the
origin, cos(30o) + sin(30o)i. Now just multiply this by your point, represented
as a complex number. The only rule you need to know to carry out
this computation is that i^2 = -1, and in what might feel like a bit of magic to those
first learning it, carrying out this product from that one simple rule gives the coordinates
of a new point, rotated 30 degrees away from the original. Using quaternions to describe 3d rotations
is similar, though the look and feel is slightly different. Let’s say you want to rotate some angle
around some axis. First, define that axis with a unit vector,
which we’ll write as having i, j and k components, normalized so that the sum of their squares
is 1. Similar to the case of complex numbers, you
use the angle to construct a quaternion by taking cos(that angle) as the real part, plus
sin(that angle) times an imaginary part, except this time the imaginary part is the 3d axis
of rotation.
Well, actually you take half that angle, which
might feel totally arbitrary, but hopefully that will make some sense by the end of this
whole experience. Now let’s say you have some 3d point, which
we’ll write with ijk, components, and you want to know the coordinates of what you’ll
get by rotating this point by your specified angle around your specified axis. What you do is not just a single quaternion
product, but a quaternion sandwich, where you multiply by q from the left and the inverse
of q from the right. If you know how i, j and k multiply amongst
themselves, you can carry out these two products by expanding everything out, or more likely
by having a computer do so. And, in what might feel like a bit of black
magic, this big computation will return for you the rotated version of the point. Our goal is to break down and visualize what’s
happening with these two products. I’ll review the method for thinking about
quaternion multiplication described last video, explain why half the angle is used, and why
you multiply from the right by the inverse.
On the screen, and at the top of the description,
is a link to the website Ben Eater setup with the explorable videos. It’s…it’s just really cool, Eater did
something awesome here. At the very least, you should go take a quick
look, but I’d love it if you went through the full experience..
