A convention for describing transforms

How to talk, write and code in a manner that makes it clear what a linear transform is describing?

Firstly, it helps to have words to differentiate the two ways we can interpret the same transform: Are we interpreting transform as being Passive or Active? A transformation matrix with the notation $T_{LV}$, can be viewed as either:

• An active transform that moves an object from $L$ to $V$, as seen from a global reference frame. This is often the context you are in when working in 3D software such as Blender or 3ds Max, you're always observing the changes from a global reference frame: the program's viewport.
• A passive transform that transforms the coordinate of a point expressed in the $V$ reference frame ${}_{V}p$ into the coordinates for the same point expressed in the $L$ reference frame ${}_{L}p$, I.e. ${}_{L}p=T_{LV}{}_{V}p$.

To be more clear, we should specify the following about a rotation and translation representation:

• Rotation
  • The frame we are rotating to.
  • The frame we are rotating from.
• Translation
  • The point we are translating to.
  • The point we are translating from.
  • The frame that this translation is expressed in.

Math Notation and How to Describe Them

Here are some useful phrases to help describe quantities and transforms and what they represent.

Vector

$${}_A\mathbf{t}_{BC}$$

The vector from B to C expressed in A.

Angular velocity

$${}_A\omega _{BC}$$

The angular velocity of frame C as seen from frame B, expressed in frame A.

Transforms

$$T_{AB}$$

"The pose of $B$ with respect to $A$" or "Transforms point from frame $B$ into frame $A$"

It is also helpful to express even more in writing:

The transformation matrix, $T_{WB}$, represents the pose of the body frame $F_B$, with respect to the world frame $F_W$, such that a point expressed in the body frame ${}_B\mathbf{p}$, can be transformed into the world frame by ${}_W\mathbf{p}=T_{WB}{}_B\mathbf{p}$.

The same phrasing can be used for pure rotations.

Notation in Code

Assuming column-vectors, the standard in Eigen and OpenGL, transforms in code can often look like this:

transformed_point = M * point;

When multiple matrices are being combined, it can become vague and hard to keep track of what is happening. Instead, a clearer way to express this is to name the variables representing transforms as A_from_B and assume that we are looking at them in the passive sense.

This has some nice benefits:

• Allows composition of transforms where it's clear what transforms fit together by seeing that the frames at the start and end of the name line up

  projection_from_object = projection_from_view * view_from_world * world_from_object
  

• Inverting a transform flips the order: object_from_world = inverse(world_from_object).

• Also works nicely with points, if they follow the rule framename_point:

  world_point = world_from_object * object_point
  

However, this requires you to talk about the transforms in the passive sense. One could use the a_to_b instead of a_from_b formulation for talking about the transforms in the active sense. However, as Sebastian Sylvan describes in their post, the a_to_b names might be better used for when dealing with row-vectors. I'm currently leaning towards assuming passive, if that is the normal case in the code base, and then specifying when I'm talking about a transform in the active sense:

// 2 ways of talking about the same transform
// A_from_B == active_A_to_B 

A_point = A_from_B * B_point // passive
point_at_B = active_A_to_B * point_at_A // active

Ideas here are mainly taken from:

• Representing robot pose by Paul Furgale
• Naming Convention for Matrix Math by Sebastian Sylvan