Rationale for using extrinsic convention

[alek5k]

Hi there,

Just wondering what the rationale is for using the extrinsic convention? Consider the following example, where t1 is rotated 30 degrees in z relative to t0, and t2 is not rotated, but positioned at coordinates (2,2) relative to t1:

I thought using the TransformManager would be intuitive enough to use with the above example, but I was getting unexpected results due to use of extrinsic conventions. For the photo above, I decided to calculate the rotations and translations manually using a post-multiply dot product:

import numpy as np
from pytransform3d import transformations as pt
from pytransform3d.transform_manager import TransformManager
from pytransform3d.transformations import concat, transform

rotation = np.deg2rad(30) 
r0_1 = np.array([
    [np.cos(rotation), -np.sin(rotation), 0],
    [np.sin(rotation), np.cos(rotation), 0],
    [0, 0, 1]])
r1_2 = np.eye(3)
p0_1 = np.array([5, 2, 0])
p1_2 = np.array([2, 2, 0])

t0_1 = pt.transform_from(r0_1, p0_1)
t1_2 = pt.transform_from(r1_2, p1_2)

print(np.dot(t0_1, t1_2))
# OUTPUT: 
# [[ 0.8660254  -0.5        0.          5.73205081]
# [ 0.5         0.8660254   0.          4.73205081]
# [ 0.          0.          1.          0.        ]
# [ 0.          0.          0.          1.        ]]

# This seems fine to me, and lets me get the transformation matrix between those two coordinate frames correctly.
# Now if I use the transform manager, and call get_transform which uses `concat` underlyingly:

tm = TransformManager()
tm.add_transform("t0", "t1", t0_1)
tm.add_transform("t1", "t2", t1_2)
print(tm.get_transform("t0", "t2"))
# OUTPUT:
# [[ 0.8660254 -0.5       0.         7.       ]
# [ 0.5        0.8660254  0.         4.       ]
# [ 0.         0.         1.         0.       ]
# [ 0.         0.         0.         1.       ]]

It's not really clear to me how I could use the output of get_transform. For instance, if I wanted to get coordinate frame t2 with t0 as the reference frame (similarly to the post-multiplied dot product), how would I go about doing this through the TransformManager?

Or alternatively, how should I be defining the above relationships using TransformManager?

I am quite used to defining transformations relative to each other, in which situations do you want to use extrinsic convention instead?

In addition, it might be worthwhile documenting that the TransformManager uses extrinsic convention, it wasn't apparent until I started digging and found the concat function that is being used.

Thanks
Aleks

[AlexanderFabisch]

Hi,

let me summarize how I understand it:

tX_Y is the name of the active transformation that transforms quantities from frame Y to frame X. You can also say tX_Y is the pose of Y in coordinate system X.

Now you add

tm.add_transform(from_frame="tX", to_frame="tY", A2B=tX_Y)

The documentation of add_transform says:

• from_frame: Name of the frame for which the transformation is added in the to_frame coordinate system
• to_frame: Name of the frame in which the transformation is defined

According to the documentation, you want to write

tm.add_transform(from_frame="tY", to_frame="tX", A2B=tX_Y)

In the end you want to query

tm.get_transform("t2", "t0")

which would result in

concat(t2_to_t1, t1_to_t0)

or

t0_1.dot(t1_2)

Output:

tm = TransformManager()
tm.add_transform("t1", "t0", t0_1)
tm.add_transform("t2", "t1", t1_2)
print(tm.get_transform("t2", "t0"))
# OUTPUT:
#[[ 0.8660254  -0.5         0.          5.73205081]
# [ 0.5         0.8660254   0.          4.73205081]
# [ 0.          0.          1.          0.        ]
# [ 0.          0.          0.          1.        ]]

I guess the confusion does not stem from the extrinsic vs. intrinsic ambiguity, but from the passive vs. active ambiguity?

[alek5k]

Hey, thanks for the explanation. I guess I misunderstood how the functions were meant to be used. Based on your wording below:

You can also say tX_Y is the pose of Y in coordinate system X.

When I called add_transform I mistakenly assumed that the to_frame parameter would be pose of Y, and from_frame would be the coordinate system X. When I read tX_Y, I usually read it like "transformation from X to Y", so to me it seemed intuitive that from_frame should be X and to_frame should be Y.

I guess when I read the function parameters at face value, I assumed it would be equivalent to the following (made up) function parameters:

tm.add_transform(in_frame="t0", frame="t1", t0_1)

I guess the key here is in the last few words of the argument documentation:

from_frame: Name of the frame for which the transformation is added in the to_frame coordinate system

Does ROS TF2 have some kind of naming convention for this?

[AlexanderFabisch]

Does ROS TF2 have some kind of naming convention for this?

I'm not sure. I only know this: https://www.ros.org/reps/rep-0103.html

I guess I misunderstood how the functions were meant to be used. Based on your wording below:

You can also say tX_Y is the pose of Y in coordinate system X.

When I called add_transform I mistakenly assumed that the to_frame parameter would be pose of Y, and from_frame would be the coordinate system X. When I read tX_Y, I usually read it like "transformation from X to Y", so to me it seemed intuitive that from_frame should be X and to_frame should be Y.

I think this is more something of a general understanding of how to interpret transformations. It's often confusing to communicate about this. We have to be really precise. That's the reason why I wrote those sections of the documentation:

• https://rock-learning.github.io/pytransform3d/transformation_modeling.html
• https://rock-learning.github.io/pytransform3d/transformation_ambiguities.html

[AlexanderFabisch]

Ah, take a look at slide 91/157 here: http://static.squarespace.com/static/523c5c56e4b0abc2df5e163e/t/53957839e4b05045ad65021d/1402304569659/Workshop+-+Rotations_v102.key.pdf

[alek5k]

Thanks, nice find.

I did some digging on TF and found the following official documentation:
http://wiki.ros.org/tf/Overview/Using%20Published%20Transforms

In particular, if you search for "lookupTransform" (section 1.5) it says the following:

The direction of the transform returned will be from the target_frame to the source_frame. Which if applied to data, will transform data in the source_frame into the target_frame.

Also in the following documentation:
http://wiki.ros.org/geometry/CoordinateFrameConventions#Transform_Direction

They say:

Transforms are specified in the direction such that they will transform the coordinate frame "frame_id" into "child_frame_id" in tf::StampedTransform and geometry_msgs/TransformStamped. This is the same transform which will take data from "child_frame_id" into "frame_id".

Do you think it might be useful to document it like this in pytransform3d? Perhaps in the examples and in the method descriptions? I like the fact that it explicitly says what happens when applied to the data separately

[AlexanderFabisch]

Yes, sure, if you have an idea how to document this, let me know or open a pull request.