Referential related to Affine transform

[romainVala]

Hello

I try to understand what is the referential used when I do a Affine transform
So I just test successive "unitary" transform (tx, ty, tz, rx, ry, rz), save the results to see what really happend

import numpy as np
import torchio as tio

sdata = tio.datasets.Colin27()
sdata.t1.save('orig.nii')
for k in range(0, 6):
    P = np.zeros(6)
    P[k] = 10.0
    Euler_angle, Translation = P[:3], P[3:]
    taff = tio.Affine([1, 1, 1], Euler_angle, Translation)
    srot = taff(sdata)
    sname = f'tio_Affine_ind{k}.nii'
    srot.t1.save(sname)

If the translation and rotation are relative to a RAS referential, I would expect,
a positive tx, would move my volume to the subject right
ty -> move to subject Anterior
tz -> move the volume toward Superior -(top)

For rotation I use the "thumb rule" to get the expected direction

Rx -> should move the anterior part toward the top
Ry -> should move the left part toward the top
Rz -> should move the anterior part toward the left

When I compare to what I obtain in a viewer, I get opposite direction only for tz, and Rz
which mean a referential of RAI ... which does not make sense ...
what do I miss ?

Looking at the code, it seems you do not do any kind of conversion from RAS to LPS when you apply a given affine, (which is apply with sitk ...) so I would expect to have a LPS referential

but I probably get again confused, with this confusing notions ...

[fepegar]

Edit: TL;DR: The arguments are being used to create an inverse LPS transform.

Hi, @romainVala. Nice research. SimpleITK uses LPS.

I've experimented and googled a bit. I just found this sentence in this SimpleITK notebook:

It is important to keep in mind that a transform in a resampling operation defines the transform from the output space to the input space.

So I guess the parameters passed to Affine are to generate the inverse transform: the one from the reference (output) to the floating (input). It hasn't been a problem before these deterministic transforms were generated for traceability, but it is indeed important for people who want to use Affine for whatever reasons. Maybe we should fix this so the sampled parameters are the ones used for the forward transform, to make everything more intuitive.

This is what I would expect:

• Tx -> move Left
• Ty -> move Posterior
• Tz -> move Superior

But the opposite happens as explained above.

• Rx -> Anterior goes down
• Ry -> Left goes down
• Rz -> Anterior goes left

But the opposite happens as explained above.

It has taken me a while to understand, but I think I do now.

Does all this make sense?

[romainVala]

thanks a lot @fepegar it makes indeed a lot of sense, this inverse issue,

the "RAI" 'affine orientation' I was observing, is indeed the inverse of LPS !
make much more sense !

[fepegar]

I've modified Affine to behave as expected:

import torchio as tio

scales = (
    0.5, 0.5,  # make smaller
)
degrees = (
    0, 0,
    0, 0,
    10, 10,  # move nose to the left
)
translation = (
    50, 50,  # move right
    0, 0,
    50, 50,  # move up
)
colin = tio.datasets.Colin27()
transform = tio.RandomAffine(
    scales=scales,
    degrees=degrees,
    translation=translation,
)
transformed = transform(colin)
print(transformed.history)
transformed.t1.plot()

[Affine(scales=(0.5, 0.5, 0.5), degrees=(0.0, 0.0, 10.0), translation=(0.0, 0.0, 50.0), center=image, default_pad_value=minimum, image_interpolation=linear)]

I'll open a PR. I need to think about how and whether the documentation should be updated. I hope you can provide some feedback about that :)

[fepegar]

Note that the anterior part of Colin is moved to the left, as expected. It moves to the right of the screen because radiological convention is used by default for plotting, so the left hemisphere is on the right hand of the screen.

As the FSL guys say:

[Orientation] is intrinsically a confusing issue

[fepegar]

PR:

• Make Affine take RAS parameters of floating->ref #712