[Insight-users] locally rigid transformations: Articulated Registration Method for Neck Images.

[Luis Ibanez]

Bill,

Thanks for pointing to the publicly available version of the paper.


        It is surprising that people still publish
        papers in Closed Access journals...


           [ ...What were they thinking ?... ]



William,

The easiest way to initiate this implementation is by requesting the
authors to share their code. Making the source code available should
be a requirement for publishing any paper in the domain of computer
science and algorithm research. The same way that depositing gene
sequences in a public database is a requisite for publishing papers
in genetics.

You may want to try this first. All of the authors are Open Source
friendly, and have submitted papers to the Insight Journal in
previous occasions.

It probably would be a good idea for the authors to submit their code
to the Insight Journal, along with a short description on how to use it.

The Insight Journal welcomes practical paper and does not reject work
that has been published elsewhere. Mainly because we are aware that most
papers published "elsewhere" are rather useless given that they are not
accompanied by the source code, images and parameters that the authors
used for performing the work described in the paper.

If you try to rewrite this code from scratch, you will discover soon
that this will take three to six months, even if you get assistance
from the authors.



------------------


In any case,

to answer your question.

The paper require at least three new software components to be
implemented in ITK:

a) A grouped transform
b) A meshing algorithm
c) A FEM based solution to Ku = -F


Item (a) is starting to be developed by Stephen Aylward, and should
be soon submitted to the Insight Journal. However if you want to
give it a shoot on your own, what you will need is to create a new
class that derives from the itkTransform and internally contains a
set itkRigidTransforms (e.g. maybe inside a std::vector of smart
pointers).  The TransformPoint method of this transform will pass
a Point through each one of the transform in order, and will result
in the composition of all the rigid transform.

Item (b) is not available, but it shouldn't be too hard to implement.
Maybe two to three weeks.

Item (c) could reuse the FEM classes available in ITK for performing
deformable registration. Note however that this should be applied
in such a way that the regions covering vertebrae are contained
inside elements with very large rigidity.



A shorter path to implementing an equivalent method
is the following:

You could go about Item (a) by simply taking advantage of the
FixedImageRegion and the ImageMask capability of the ITK metrics.
You could use these feature for restricting a rigid registration
to use only the region containing *one vertebra* and some surrounding
tissue.  If you do this starting from the inferior vertebrae, you
can use the results of registering one vertebra, as the initialization
for starting the registration of the next one in the superior direction.

For example, you would register C7 first, and then use the resulting
rigid transform for initializing the registration of C6, then use the
result of C6 for initializing the registration of C5.. and so on.

This, can be done with the current image registration framework, and
the aid of some customized GUI that allows you to select the region
around each one of the vertebrae.

If you create masks around each one of the vertebrae in the Fixed
image, these masks can be used for performing the registration
described above (see the ITK Software Guide for details on how to
use masks for restricting the set of pixels that participate in the
registration process).

A cheap way of avoiding to implement (b) and (c) is to do the following:


A) take all the masks that you used for the registration
    and compute distance maps to them.

B) When mapping a point that is not inside the rigid regions,
    get its distance to a rigid region by using the distance
    maps that you computed in (A).

C) Use those distances as weights in a linear combination of the
    rigid transformations. Then use that resulting transform for
    mapping the point to the moving image.


This method would give you C1 continuity in the deformation.

It may not give you pretty equations like the ones used typically
in *closed access* Journals, but it will give you a method that
you can implement in a couple of days of coffee-rich programming.


Please let us know if you have further questions,


    Thanks


       Luis




-----------------------
Bill Lorensen wrote:
> Luis,
> 
> The authors have already posted it: 
> http://www.cilab.upf.edu/~mdecraene/pdf/embc2005/duboisdaische_embc05.pdf
> 
> 
> Bill
> 
> On Jan 17, 2008 8:20 AM, Luis Ibanez <luis.ibanez at kitware.com 
> <mailto:luis.ibanez at kitware.com>> wrote:
> 
> 
> Hi Willliam,
> 
> We would love to look at this paper, but unfortunately, this
> publication is not available in *Open Access*.
> 
> Could you please point us to a publicly available version of this
> paper ?
> 
> Maybe you could request the authors to post a PDF version of their
> paper online.
> 
> 
> 
> Thanks,
> 
> 
> Luis
> 
> 
> ------------------------ William Am wrote:
>> Hi all,
>> 
>> How might one begin implementing propagation of locally rigid 
>> transformations as described in the work below?
>> 
>> http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=1616288
>> 
>> Thanks, Will
> _______________________________________________ Insight-users mailing
> list Insight-users at itk.org <mailto:Insight-users at itk.org> 
> http://www.itk.org/mailman/listinfo/insight-users
> 
>