1 / 43

Quaternions

Quaternions. Bryan Duggan. So far!. Yaw – Rotation around the Y Axis Pitch – Rotation around X Axis Roll – Rotation around the Z Axis Look Vector – A Unit Vector giving the orientation of an object The direction something is pointing. In DirectX we usually…. Use 4 x 4 matrices

benedict
Download Presentation

Quaternions

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Quaternions Bryan Duggan

  2. So far! • Yaw – Rotation around the Y Axis • Pitch – Rotation around X Axis • Roll – Rotation around the Z Axis • Look Vector – A Unit Vector giving the orientation of an object • The direction something is pointing

  3. In DirectX we usually… • Use 4 x 4 matrices • Use the D3DXMATRIX class to represent a 4 x 4 matrix • Use 1 for the 4th element of the vector matrix • Multiply vectors by matrices • To do transformations • Multiply matrices by matrices • To combine transformations

  4. Pitch - X-Axis Rotation • To rotate a vector • θ Radians in a clockwise direction looking down the x axis • Multiply the vector by the following matrix: Use: D3DXMatrixRotationX( D3DXMATRIX * m ,float angle);

  5. Yaw - Y-Axis Rotation • To rotate a vector • θ Radians in a clockwise direction looking down the Y axis • Multiply the vector by the following matrix: Use: D3DXMatrixRotationY( D3DXMATRIX * m ,float angle);

  6. Roll - Z-Axis Rotation • To rotate a vector • θ Radians in a clockwise direction looking down the Z axis • Multiply the vector by the following matrix: Use: D3DXMatrixRotationZ( D3DXMATRIX * m ,float angle);

  7. Combining Transformations • We can combine transformations together by multiplying the matrices together to get a single transformation matrix • This means we can apply the same transformations to the multiple vectors • The order that you multiply is the order the transformations are carried out!!!

  8. Interpolation • In order to “move things”, we need both translation and rotation • Interpolation the translation is easy, but what about rotations? • How do you interpolate matrices or look vectors? • How about interpolating each entry of the rotation matrix? • The interpolated matrix might no longer be orthonormal, leading to nonsense for the in-between rotations

  9. Solution 1: Fixed Angles • Angles used to rotate about fixed axes • Orientations are specified by a set of 3 ordered parameters that represent 3 ordered rotations about fixed axes • A 3D Vector: • X = Pitch • Y = Yaw • Z = Roll • Many possible orderings!! • x(90)y(90) is different from y(90)x(90)

  10. Euler Angles • This means that we can represent an orientation with 3 numbers • A sequence of rotations around principle axes is called an Euler Angle Sequence • Assuming we limit ourselves to 3 rotations without successive rotations about the same axis, we could use any of the following 12 sequences: XYZ XZY XYX XZX YXZ YZX YXY YZY ZXY ZYX ZXZ ZYZ

  11. Solution 2: Euler Angles • Same as fixed angles, except now the axes move with the object • An Euler angle is a rotation about a single Cartesian axis • Create multi-DOF rotations by concatenating Euler angles • evaluate each axis independently in a set order

  12. Euler Angles • This gives us 12 redundant ways to store an orientation using Euler angles • Different industries use different conventions for handling Euler angles (or no conventions)

  13. Euler Angles to Matrix Conversion • To build a matrix from a set of Euler angles, we just multiply a sequence of rotation matrices together • To use Euler angles, one must choose which of the 12 representations they want • There may be some practical differences between them and the best sequence may depend on what exactly you are trying to accomplish

  14. Euler Angle Order • As matrix multiplication is not commutative, the order of operations is important • Rotations are assumed to be relative to fixed world axes, rather than local to the object • One can think of them as being local to the object if the sequence order is reversed

  15. Vehicle Orientation • Generally, for vehicles, it is most convenient to rotate in roll (z), pitch (x), and then yaw (y) • In situations where there is a definite ground plane, Euler angles can actually be an intuitive representation front of vehicle

  16. Z Y X Euler angle vs. fixed angle • Rz(90)Ry(60)Rx(30) = Ex(30)Ey(60)Ez(90) • Euler angle rotations about moving axes written in reverse order are the same as the fixed axis rotations

  17. Gimbal Lock • One potential problem that they can suffer from is ‘gimbal lock’ • This results when two axes effectively line up, resulting in a temporary loss of a degree of freedom • This is related to the singularities in longitude that you get at the north and south poles

  18. Gimbal Lock • A Gimbal is a hardware implementation of Euler angles used for mounting gyroscopes or expensive globes • Gimbal lock is a basic problem with representing 3D rotation using Euler angles or fixed angles

  19. Gimbal Lock • When two rotational axis of an object pointing in the same direction, the rotation ends up losing one degree of freedom

  20. Interpolating Euler Angles • One can simply interpolate between the three values independently • This will result in the interpolation following a different path depending on which of the 12 schemes you choose • This may or may not be a problem, depending on your situation • Interpolating near the ‘poles’ can be problematic • Note: when interpolating angles, remember to check for crossing the +180/-180 degree boundaries

  21. Euler Angles • Euler angles are used in a lot of applications, but they tend to require some rather arbitrary decisions • They also do not interpolate in a consistent way (but this isn’t always bad) • They can suffer from Gimbal lock and related problems • There is no simple way to concatenate rotations • Conversion to/from a matrix requires several trigonometry operations • They are compact (requiring only 3 numbers)

  22. Axis angle • Represent orientation as a vector and a scalar • vector is the axis to rotate about • scalar is the angle to rotate by

  23. Axis/Angle to Matrix • To generate a matrix as a rotation θ around an arbitrary unit axis a: • In DirectX: • D3DXMatrixRotationAxis

  24. Axis/Angle Representation • Storing an orientation as an axis and an angle uses 4 numbers, but Euler’s theorem says that we only need 3 numbers to represent an orientation • Mathematically, this means that we are using 4 degrees of freedom to represent a 3 degrees of freedom value • This implies that there is possibly extra or redundant information in the axis/angle format • The redundancy manifests itself in the magnitude of the axis vector. The magnitude carries no information, and so it is redundant. To remove the redundancy, we choose to normalize the axis, thus constraining the extra degree of freedom • Lots of bounds checking to verify that the values are valid • Hard to interpolate

  25. Matrix Representation • We can use a 3x3 matrix to represent an orientation as well • This means we now have 9 numbers instead of 3, and therefore, we have 6 extra degrees of freedom • NOTE: We don’t use 4x4 matrices here, as those are mainly useful because they give us the ability to combine translations. We will not be concerned with translation today, so we will just think of 3x3 matrices.

  26. Matrix Representation • Matrices are usually the most computationally efficient way to apply rotations to geometric data, and so most orientation representations ultimately need to be converted into a matrix in order to do anything useful (transform verts…) • Why then, shouldn’t we just always use matrices? • Numerical issues • Storage issues • Interpolation issues

  27. Look Vectors • To convert a scaled look vector to a matrix, one would have to extract the magnitude out of it and then rotate around the normalized axis • Normally, rotation vector format is more useful for representing angular velocities and angular accelerations, rather than angular position (orientation)

  28. Quaternions

  29. Quaternions • Quaternions are an interesting mathematical concept with a deep relationship with the foundations of algebra and number theory • Invented by W.R.Hamilton in 1843 • In practice, they are most useful to us as a means of representing orientations • A quaternion has 4 components: • D3DXQUATERNION(x, y, z, w)

  30. Quaternions (Imaginary Space) – Feel free to Ignore!! • Quaternions are actually an extension to complex numbers • Of the 4 components, one is a ‘real’ scalar number, and the other 3 form a vector in imaginary ijk space!

  31. Unit Quaternions • For convenience, we will use only unit length quaternions, as they will be sufficient for our purposes and make things a little easier • D3DXQuaternionNormalise(& out, & in);

  32. Quaternions as Rotations • A quaternion can represent a rotation by an angle θ around a unit axis axis:q.w = cosf( theta/2) • q.x = axis.x * sinf(theta /2 ) • q.y = axis.y * sinf(theta /2 ) • q.z = axis.z * sinf(theta /2 ) • If axis is unit length, then q will be also

  33. Quaternion Multiplication • We can perform multiplication on quaternions if we expand them into their complex number form • If q represents a rotation and q’ represents a rotation, then qq’ represents q rotated by q’ • This follows very similar rules as matrix multiplication (I.e., non-commutative) • (Q1 * Q2).w = (Q1.wQ2.w - Q1.xQ2.x - Q1.yQ2.y - Q1.zQ2.z) • (Q1 * Q2).x = (Q1.wQ2.x + Q1.xQ2.w + Q1.yQ2.z - Q1.zQ2.y) • (Q1 * Q2).y = (Q1.wQ2.y - Q1.xQ2.z + Q1.yQ2.w + Q1.zQ2.x) • (Q1 * Q2).z = (Q1.wQ2.z + Q1.xQ2.y - Q1.yQ2.x + Q1.zQ2.w

  34. Quaternion Multiplication • Note that two unit quaternions multiplied together will result in another unit quaternion • This corresponds to the same property of complex numbers • Remember that multiplication by complex numbers can be thought of as a rotation in the complex plane • Quaternions extend the planar rotations of complex numbers to 3D rotations in space

  35. Constructing a Quaternion • D3DXQuaternionIdentity(& q); • D3DXQuaternionRotationAxis(& q, & axis, theta); • D3DXQuaternionYawPitchRoll(& q, yaw, pitch, roll);

  36. Rotating a Vector by a Quaternion • Rotate a vector by a quaternion: • w = q * w * q-1 • Where q = quaternion and w = a pure quaternion made from the vector to be rotated (w = 0) • This is called CONJUGATION

  37. Converting Quaternions • Convert a quaternion to a matrix: • D3DXMatrixRotationQuaternion(& m, & q) • Convert a matrix to a quaternion: • D3DXQuaternionRotationMatrix(&q, &m)

  38. Some useful quaternions

  39. Quaternion Interpolation

  40. Linear Interpolation • If we want to do a linear interpolation between two points a and b in normal space Lerp(t,a,b) = (1-t)a + (t)b where t ranges from 0 to 1 • Note that the Lerp operation can be thought of as a weighted average (convex) • We could also write it in it’s additive blend form: Lerp(t,a,b) = a + t(b-a)

  41. Spherical Linear Interpolation • If we want to interpolate between two points on a sphere (or hypersphere), we don’t just want to Lerp between them • Instead, we will travel across the surface of the sphere by following a ‘great arc’

  42. Spherical Linear Interpolation • We define the spherical linear interpolation of two unit vectors in N dimensional space as:

  43. In Code: • D3DXQUATERNION * D3DXQuaternionSlerp(D3DXQUATERNION *pOut,CONST D3DXQUATERNION *pQ1,CONST D3DXQUATERNION *pQ2,FLOATt); • Where t is a value between 0 and 1

More Related