The elementary functions in *Spatial_v2* deal
with four different kinds of coordinate system: Cartesian coordinates for 2-D
and 3-D points and Euclidean vectors, Plücker coordinates for spatial
vectors, planar coordinates (a subset of Plücker coordinates) for planar
vectors, and homogeneous coordinates for points in 3-D space.
(Homogeneous coordinates appear only in the
function pluho, which converts between
Plücker and homogeneous coordinate transforms.) These coordinate
systems all have one thing in common: they are defined by the location of a
Cartesian coordinate frame. Specifically, a Cartesian coordinate system
for vectors (not points) is defined by the *orientation* of its
coordinate frame; but Plücker, planar and homogeneous coordinates, as
well as Cartesian coordinates for points, are all defined by the *position
and orientation* of their coordinate frame. Furthermore, the
relationship between a coordinate system and its frame is 1:1. So, for
example, the set of all Plücker coordinate systems stands in 1:1
correspondence with the set of all positions and orientations of a Cartesian
frame in 3-D space. (Various descriptions of Plücker coordinates
can be found on the
spatial vectors home page.)

Given this close connection between frames and coordinate systems, it becomes
convenient to use the same name to identify both the frame and the coordinate
systems it defines. For example, a 3-D coordinate frame **A** defines
both a 3-D Cartesian coordinate system **A** and a Plücker coordinate
system **A**. Any possibility of ambiguity can be removed simply by
identifying the type of vector under discussion. For example, in a
statement like '…spatial velocity **v** expressed in **A**
coordinates…' it is clear that '**A** coordinates' must refer to the
Plücker coordinate system defined by frame **A**.

The purpose of a coordinate vector is to represent some physical quantity or
phenomenon in a particular coordinate system. For example, if we say
that a rigid body has a spatial velocity of **v**, and
that **v _{A}** is the coordinate vector representing

Let **v _{A}** and

All Euclidean vectors (of a given dimension) follow the same transformation
rule, regardless of whether the vectors represent motions or forces.
However, the same is not true of spatial and planar vectors.
Let **m** denote a spatial or planar motion vector (such as a velocity, an
acceleration or a joint axis); let **f** denote a spatial or planar force
vector (such as a force, an impulse or a momentum); and
let **m _{A}**,

This difference between the way that motion and force vectors behave has
consequences for the matrices representing inertia, stiffness, and other such
quantities. Basically, we find that there are four possible
transformation rules, depending on whether the matrix represents something
that maps motion to motion, motion to force, force to motion, or force to
force. The table below sets out the various formulae. There are
also consequences for the way the software is organized.
*Spatial_v2* adopts the convention that every
Plücker or planar coordinate transform that is either returned as a
result, or accepted as an argument, is expected to be a coordinate transform
for motion vectors. In the table below, **X** is the transform
from **A** to **B** coordinates for motion vectors.

Type | Example | Coordinate Transform Rules | ||||
---|---|---|---|---|---|---|

motion vector | velocity | m_{B} = X*m_{A} |
m_{A} = X^{−1}*m_{B} |
|||

force vector | force | f_{B} = X^{−T}*f_{A} |
f_{A} = X^{T}*f_{B} |
|||

motion to force | inertia | I_{B}
= X^{−T}*I_{A}*X^{−1} |
I_{A} = X^{T}*I_{B}*X |
|||

force to motion | inverse inertia | Φ_{B} = X*Φ_{A}*X^{T} |
Φ_{A}
= X^{−1}*Φ_{B}*X^{−T} |
|||

motion to motion | crm(v) |
M_{B} = X*M_{A}*X^{−1} |
I_{A} = X^{−1}*M_{B}*X |
|||

force to force | crf(v) |
F_{B}
= X^{−T}*F_{A}*X^{T} |
F_{A}
= X^{T}*F_{B}*X^{−T} |

When a matrix is used to translate and/or rotate a coordinate system, it is
called a coordinate transform. When a matrix is used to translate and/or
rotate a geometrical object (points, lines, vectors, triangles, etc.), it is
called a *displacement operator*. Terms like 'rotation operator',
'rotation matrix' and 'translation matrix' are commonly used when the
displacement happens to be a rotation about the origin or a pure translation.

The distinction between these two kinds of matrix is important because they
are closely related and easily confused (and confusion leads to
mistakes). To illustrate the difference, let **u** be a Euclidean
vector, and let **v** be the result of rotating **u** in a certain
way. (So **v** has the same magnitude as **u**, but points in a
different direction.) Also, let **A** and **B** be any two
coordinate frames such that **B** is rotated relative to **A** in the
same way that **v** is rotated relative to **u**. If **E** is
the coordinate transform from **A** to **B**, and **R** is the
displacement operator, then we have **u _{B}=E*u_{A}**
and

In this example, it can easily be shown
that **R=E ^{−1}**. However, this is just a special case
of a more general result, which is that

Why do you need to know this? Well, displacement operators are widely
used in applications such as 3-D graphics and computer-aided design
(CAD). The 4x4 matrices used in Matlab handle graphics, for example, are
displacement operators, and so are the matrices in the Open-GL graphics
library. If you want to interface
*Spatial_v2* with other software packages then
you need to know whether those other packages expect coordinate transforms or
displacement operators.

At this point, you might be wondering why
*Spatial_v2* uses coordinate transforms when
displacement operators are so widely used. The answer lies in the
application. In 3-D graphics, or CAD, the idea is to create geometrical
objects; and typically one does this by creating an object in a standard
location, and then moving it from where it was created to where it is supposed
to be. Displacement operators are the natural tool for this kind of
work. In dynamics, on the other hand, all the bodies and joints already
exist, and are already in their correct positions; and the task is to perform
calculations local to each body and combine the results with those from other
bodies. For this kind of work, it is convenient to assign a coordinate
frame to each body, and employ coordinate transforms to move data around from
one coordinate system to another.

Page last modified: June 2012

Author: Roy Featherstone