[Insight-developers] Question regardingitk::SymmetricDemonsForceRegistrationFunction::ComputeUpdate()

[Miller, James V (Research)]

Torsten,

Both the symmetric and non-symmetric cases keep track of the 
SumofSquaredChange and the SumOfSquaredDifference in the global 
data structure. 

The "difference" is that the non-symmetric case calculates the 
SumOfSquaredDifference as the difference between the fixed and moving
image using the deformation field from the previous iteration, i.e.
the SumOfSquaredDifference BEFORE the new update field is calculated.

The symmetric case calculates the SumOfSquaredDifference as the 
difference between the fixed and moving image using the deformation
field calculated by the CURRENT iteration, i.e. the SumOfSquaredDifferences
AFTER the new update field is calculate.

So, the SumOfSquaredDifference in the non-symmetric case is the alignment
error at the beginning of an iteration, whereas for the symmetric case, it is 
the alignment error at the end of an iteration.

The non-symmetric case may perform one additional iteration if the metric 
value was used as a termination criterion.

The symmetric case is probably more correct since it allows you to decide
whether you have converged before you start the next iteration rather 
than running an iteration and finding out you should had converged at the
previous iteration.  

But the approach used in the symmetric case will be slower since it requires
interpolating the moving image twice per pixel (once to calculate the update
and once to calculate the contribution to the final align error).

Jim




-----Original Message-----
From: insight-developers-bounces+millerjv=crd.ge.com at itk.org
[mailto:insight-developers-bounces+millerjv=crd.ge.com at itk.org]On Behalf
Of Torsten Rohlfing
Sent: Thursday, May 05, 2005 7:22 PM
To: insight-developers at itk.org
Subject: [Insight-developers] Question
regardingitk::SymmetricDemonsForceRegistrationFunction::ComputeUpdate()



Hi --

This is not particularly important, but I was wondering if someone can 
help me understand something I find slightly sketchy about the 
implementation of 
itk::SymmetricDemonsForceRegistrationFunction::ComputeUpdate().

Towards the end of the function, there is a block labeled "update the 
metric with the latest deformable field". What happens there is that in 
the global data structure, the mean squared difference between fixed and 
moving image is updated with the metric value AFTER applying the current 
update. Or I should say: supposedly that's what happens.

I am wondering whether this is really necessary (it does take some extra 
CPU time after all)? The non-symmetric force class does not do this, and 
I can't figure out where this is ever used? Also, it does not seem 
particularly meaningful, since the update computed in ComputeUpdate is 
not necessarily applied fully in the respective registration filter's 
ApplyUpdate() member function. There may be smoothing, for example, of 
either the update or the updated deformation field. So the value that is 
computed in ComputeUpdate() for the MSD after applying the update is not 
actually guaranteed to be correct anyway.

Any thoughts would be greatly appreciated.

Best,
  Torsten

-- 
Torsten Rohlfing, PhD          SRI International, Neuroscience Program
 Research Scientist             333 Ravenswood Ave, Menlo Park, CA 94025
  Phone: ++1 (650) 859-3379      Fax: ++1 (650) 859-2743
   torsten at synapse.sri.com        http://www.stanford.edu/~rohlfing/

     "Though this be madness, yet there is a method in't"

_______________________________________________
Insight-developers mailing list
Insight-developers at itk.org
http://www.itk.org/mailman/listinfo/insight-developers