No subject

Mon Aug 10 18:29:21 EDT 2009

"The idea behind using G to decide on regions
of mismatch is as follows: if the magnitude of the gradient
of the cost function with respect to the coefficient C_i is large,
then the cost function is not at a minimum with respect to C_i .
If the cost function is not at a minimum at the location corresponding
to C_i then it is likely that the region where the corresponding
basis function is located is misregistered"

>
> If you want to go down this road, you could as well try the Kernel
> Transforms,
> which will perform interpolations such as ThinPlate Splines.

This sounds interesting. I am not sure I understand the primary difference
between kernel transforms and the eg. BSplineDeformableTransform. I thought
that the BSplineDeformableTransform was using a BSpline kernel
implementation to evaluate the image intensities/function values.

>
>
>
> In any case,
>
> This will make a great paper for the Insight Journal   :-)
>
>
>       Regards,
>
>
>              Luis
>
>
>
> -------------------------------------------------------------------------------------------
> On Mon, Aug 10, 2009 at 4:12 AM, motes motes <mort.motes at gmail.com> wrote:
>
>> When using the BSplineDeformationTransform something like this is
>> typically done:
>>
>> ...
>> ...
>>     for( unsigned int i=0; i< SpaceDimension; i++ ) {
>>       spacing[i] = fixedSpacing[i] * (fixedSize[i] - 1) /
>> numberOfGridCells;
>>     }
>>     origin  = fixedOrigin - fixedDirection * spacing;
>>     bsplineTransform->SetGridSpacing(spacing);
>>     bsplineTransform->SetGridOrigin(origin);
>>     bsplineTransform->SetGridRegion(bsplineRegion);
>>     bsplineTransform->SetGridDirection(fixedDirection);
>>     const unsigned int numberOfParameters =
>> bsplineTransform->GetNumberOfParameters();
>>     const unsigned int numberOfNodes = numberOfParameters /
>> SpaceDimension;
>> ...
>> ...
>>
>>
>>
>> In the first loop the position of the deformation vectors are initialized.
>> During the image registration process as I understand the position of the
>> deformation vectors are not changed, only the magnitude and direction of the
>> vectors are modified.
>>
>> But would the BSplineDeformableTransform not improve the registration
>> result if it was somehow (based on a well chosen heuristic) possible to also
>> move the position of the deformation vectors?
>>
>> Are there any articles or other ITK information that deals with a more
>> flexible approach to the position of the deformation vectors?
>>
>> _____________________________________
>> Powered by www.kitware.com
>>
>> Visit other Kitware open-source projects at
>> http://www.kitware.com/opensource/opensource.html
>>
>> Please keep messages on-topic and check the ITK FAQ at:
>> http://www.itk.org/Wiki/ITK_FAQ
>>
>> Follow this link to subscribe/unsubscribe:
>> http://www.itk.org/mailman/listinfo/insight-users
>>
>>
>

--000e0cd2513e6dc27a0471338362
Content-Type: text/html; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable

<div class=3D"gmail_quote">On Sat, Aug 15, 2009 at 8:54 PM, Luis Ibanez <sp=
an dir=3D"ltr">&lt;<a href=3D"mailto:luis.ibanez at kitware.com">luis.ibanez at k=
itware.com</a>&gt;</span> wrote:<br><blockquote class=3D"gmail_quote" style=
=3D"border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; p=
adding-left: 1ex;">
Hi Motes,<br><br>Your understanding on how the BSplineDeformableTransform w=
orks<br>is correct.</blockquote><div><br><br>=A0</div><div><br><br>I am sti=
ll not sure I quite understand how the deformation vectors are placed.<br>

I read up on some of the details in the itkSoftwareGuide. On page 40
the concept of &#39;spacing&#39; is very well illustrated and explained. No=
w
the loop (a bit modified from the previous example): 
 
=A0 RegionType::SizeType gridSizeOnImage; 
=A0 gridSizeOnImage.Fill(5); 
=A0 SpacingType spacing =3D fixedImage-&gt;GetSpacing(); 
 
=A0=A0=A0 =A0=A0=A0 for(unsigned int r=3D0; r&lt;Dimension; r++) { 
=A0=A0=A0 =A0=A0=A0 =A0=A0=A0 spacing[r] *=3D static_cast&lt;double&gt;(fix=
edImageSize[r] - 1)=A0 / static_cast&lt;double&gt;(gridSizeOnImage[r] - 1);=
 
=A0=A0=A0 =A0=A0=A0 } 
 
actually just scales the spacing between pixel centers. If the image is
a 3D volume the spacing is a 3 component vector where each element
specified the distance/spacing between pixel centers in each dimension. 
 
But what does this have to do with the position of the deformation vectors?=
 
 
Assume that I would like to change the initial position of one of the defor=
mation vectors, how would that be possible? =A0</div><blockq=
uote class=3D"gmail_quote" style=3D"border-left: 1px solid rgb(204, 204, 20=
4); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;">
 The locations of the nodes are never modified. The registrat=
ion process only computes new values for the magnitude 
and direction of the vectors associated with the nodes. It may be po=
ssible to get more adjustable fields by moving the nodes as well,... but=
 then you have to deal with a new interpolation for computing the deform=
ation vectors in all the intermediate locations, and of course,

you should come up with the heuristic on how to move the node locations.<br=
></blockquote><div><br><br><br><br>I am thinking of using this paper as sta=
rting point:<br><br><strong>The adaptive bases algorithm for intensity-base=
d nonrigid image registration</strong><br>

            Rohde, G.K.; Aldroubi, A.; Dawant, B.M.<br><br><a href=3D"http:=
//www.contrib.andrew.cmu.edu/~gustavor/rohde_tmi_03.pdf">http://www.contrib=
.andrew.cmu.edu/~gustavor/rohde_tmi_03.pdf</a><br><br>From the paper:<br>
<br>&quot;The idea behind using G to decide on regions<br>of mismatch is as=
 follows: if the magnitude of the gradient<br>of the cost function with res=
pect to the coefficient C_i is large,<br>then the cost function is not at a=
 minimum with respect to C_i .<br>
If the cost function is not at a minimum at the location corresponding<br>t=
o C_i then it is likely that the region where the corresponding<br>basis fu=
nction is located is misregistered&quot;<br><br><br>=A0</div><blockquote cl=
ass=3D"gmail_quote" style=3D"border-left: 1px solid rgb(204, 204, 204); mar=
gin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;">
<br>If you want to go down this road, you could as well try the Kernel Tran=
sforms,<br>which will perform interpolations such as ThinPlate Splines.</bl=
ockquote><div><br><br>This sounds interesting. I am not sure I understand t=
he primary difference between kernel transforms and the eg. BSplineDeformab=
leTransform. I thought that the BSplineDeformableTransform was using a BSpl=
ine kernel implementation to evaluate the image intensities/function values=
.<br>
<br><br>=A0</div><blockquote class=3D"gmail_quote" style=3D"border-left: 1p=
x solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;">=
<br>
<br><br>In any case,<br><br>This will make a great paper for the Insight Jo=
urnal=A0=A0 :-)<br><br><br>=A0=A0=A0=A0=A0 Regards,<br><br><br>=A0=A0=A0=A0=
=A0=A0=A0=A0=A0=A0=A0=A0 Luis<br><br><br>----------------------------------=
---------------------------------------------------------<br>

<div class=3D"gmail_quote"><div><div></div><div class=3D"h5">On Mon, Aug 10=
, 2009 at 4:12 AM, motes motes <span dir=3D"ltr">&lt;<a href=3D"mailto:mort=
.motes at gmail.com" target=3D"_blank">mort.motes at gmail.com</a>&gt;</span> wro=
te:<br>
</div></div><blockquote class=3D"gmail_quote" style=3D"border-left: 1px sol=
id rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;"><div>=
<div></div><div class=3D"h5">
When using the BSplineDeformationTransform something like this is typically=
 done:<br><br>...<br>...<br>=A0=A0=A0 for( unsigned int i=3D0; i&lt; SpaceD=
imension; i++ ) {<br>=A0=A0=A0=A0=A0 spacing[i] =3D fixedSpacing[i] * (fixe=
dSize[i] - 1) / numberOfGridCells;<br>

=A0=A0=A0 }<br>=A0=A0=A0 origin=A0 =3D fixedOrigin - fixedDirection * spaci=
ng;<br>=A0=A0=A0 bsplineTransform-&gt;SetGridSpacing(spacing);<br>=A0=A0=A0=
 bsplineTransform-&gt;SetGridOrigin(origin);<br>=A0=A0=A0 bsplineTransform-=
&gt;SetGridRegion(bsplineRegion);<br>

=A0=A0=A0 bsplineTransform-&gt;SetGridDirection(fixedDirection);<br>=A0=A0=
=A0 const unsigned int numberOfParameters =3D bsplineTransform-&gt;GetNumbe=
rOfParameters();<br>=A0=A0=A0 const unsigned int numberOfNodes =3D numberOf=
Parameters / SpaceDimension;<br>

... ... In the first loop the position of the deformation=
 vectors are initialized. During the image registration process as I unders=
tand the position of the deformation vectors are not changed, only the magn=
itude and direction of the vectors are modified.

<br>But would the BSplineDeformableTransform not improve the registration r=
esult if it was somehow (based on a well chosen heuristic) possible to also=
 move the position of the deformation vectors?<br><br>Are there any article=
s or other ITK information that deals with a more flexible approach to the =
position of the deformation vectors?<br>

<br></div></div>_____________________________________<br>
Powered by <a href=3D"http://www.kitware.com" target=3D"_blank">www.kitware=
.com</a><br>
<br>
Visit other Kitware open-source projects at<br>
<a href=3D"http://www.kitware.com/opensource/opensource.html" target=3D"_bl=
ank">http://www.kitware.com/opensource/opensource.html</a><br>
<br>
Please keep messages on-topic and check the ITK FAQ at: <a href=3D"http://w=
ww.itk.org/Wiki/ITK_FAQ" target=3D"_blank">http://www.itk.org/Wiki/ITK_FAQ<=
/a><br>
<br>
Follow this link to subscribe/unsubscribe:<br>
<a href=3D"http://www.itk.org/mailman/listinfo/insight-users" target=3D"_bl=
ank">http://www.itk.org/mailman/listinfo/insight-users</a><br>
<br></blockquote></div><br>
</blockquote></div><br>

--000e0cd2513e6dc27a0471338362--