[Insight-users] Optimizing transforms

[Thomas Boettger]

Dear ITK-users,

lately a colleague asked me about how to choose thje 'right' optimizer
for different transforms in ITK and I thought I knew the answer or at
least the software guide could help me.
But I soon figured out that it is not that simple. And there are at
least some important facts missing in the documentation, which I would
like to discuss. It would be interesting to get other users comments
on the problems I ran into.

We want to solve the following scenario:

I want to optimize a points metric using ICP and start with a
Rigid3DTransform and the Levenberg-Marquardt optimizer (just like in
the examples). The optimizer gets passed an array of 12 parameters and
is in fact optimizing the transform as if it were an affine one. I
tested it with the affine transform and the Rigid3DTransform. Results
were the same. I do not wonder, because how would the optimizer know
the difference between an affine matrix and a rigid matrix... You
cannot optimize Rigid3DTransforms? Where is my mistake? If this is
true, I think this fact should be mentioned somewhere in the
documentation.

Optimization works with the Euler3DTransform. It does not work for the
VersorRigid3D transform as the VersorTransform needs the
VersorTransform optimizer which is a single valued one and does not
work with PointsetToPointset metrics...(I can write my own metric...I
know)

Then I went from rigid transformations to similarity transforms.
Unfortunately I looked at Similarity2DTransform and played around with
it and it worked. Then I went to the 3D case and wanted to do the same
as I did with the rigid transform before. It did not work. After a
while I figured out that Similarity3DTransform is derived from the
VersorRigid3DTransform. Then I would have to use the VersorOptimizer(
single valued... pointset metric... write my own... ) What about the
LM-Optimizer? Why? Couldn't one derive a Similarity3DTransform class
from the Euler3DTransform? Everything would be easy.

Or another question could be: Why is Similarity2D derived from Rigid2D
and Similarity3D from VersorRigid3D?

It would be great if someone could explain to me the concept behind
all these design decisions.

All those little things stop me from using different transforms in a
rather exchangable way in my optimization scheme, because a different
transform sometimes even implies different optimizers. And i finally
do not benefit from the generality of the registration framework
design. It only makes things complicated for me.

Please let me know if I do something fundementally wrong.


  Best regards,

    Thomas