[Insight-users] Polar transforms
Jakub Bican
jakub.bican at matfyz.cz
Sat May 21 05:13:02 EDT 2005
Thanks Luis,
here are my classes. I will implement the tests in upcomming week. Till that
time, anyone can send me comments to the classes, implementation, docs,
classnames(!!), etc,etc.. i am open to discuss and implement any
suggestions.
Question: is it possible to write just one test file for all four classes,
or should it be splitted somehow? Any other conventions (naming...)??
Regards,
Jakub
----- Original Message -----
From: "Luis Ibanez" <luis.ibanez at kitware.com>
To: "Jakub Bican" <jakub.bican at matfyz.cz>
Cc: <insight-users at itk.org>
Sent: Thursday, May 19, 2005 5:39 PM
Subject: Re: [Insight-users] Polar transforms
>
>
> Hi Jakub,
>
>
> Thanks for your willingness to contribute your code to ITK.
>
> We will be happy to add your transform to the toolkit.
>
> Could you please send us the files (.h and .txx) along with
> a test for this transform. The test should exercise all the
> methods of the new class.
>
> Please let us know too how do you want the credits for authorship
> to be listed in the header file. Typicall we follow the Doxygen
> format of:
>
>
> \author John Doe, Department of Surgery, University of Zion
>
>
>
> Thanks
>
>
> Luis
>
>
>
> ---------------------
> Jakub Bican wrote:
>
> >
> > Hi all,
> >
> > i am implementing a multidimensional polar transform. It transforms
> > first two dimensions of cartesian space into <angle,radius> coordinates,
> > leaving the other dimensions unchanged (i.e. - multidimensional
> > cylindric transform). I have implemented both forward and backward
> > transforms. To transform space to cylinder in general position (to
> > transform other than first two dimensions), it is neccessary to
> > transform the image first by for example Euler3DTransform, or
> > PermuteAxesImageFilter. To avoid excess memory and time, i implemented
> > PermuteAxesTransform, which does the same as the filter, but it is a
> > transform.
> >
> > Now i have two possibilities what to do:
> > 1) imlement something like "bulk transform" as it is in
> > BSplineDeformableTransform into the polar transforms, or
> >
> > 2) implement general "ComposeTransformsTransform", which keeps a queue
> > of transforms and successively transforms points and vectors by all of
> > them. So it is possible to do several transforms in just one
> > ResampleImageFilter.
> >
> > I find the second solution more laborious but principally much more
> > useful. But before i will do it, i need to know surely, if there is not
> > such class in ITK yet, because i did not find it and i think that it is
> > really useful and it should be implemented. Or is there any other way
> > how to pass several transforms into one ResampleImageFilter??
> >
> > I also found AzimuthElevationToCartesianTransform class in ITK. This
> > does a kind of spheric transform and i must say that it is implemented
> > badly. It uses several parameters to "sample" the "polar" space once
> > more. All these parameters are redundant to properly set Size, Spacing
> > and Origin parameters of ResampleImageFilters output and only comlicates
> > the situation. Keeping in mind that transforms are transforming "real"
> > coordinates, such transforms as polar, cylindric or spheric do not need
> > any parameters. Everything is just question of proper sampling of input
> > and output space.
> >
> > Finally, i found several requests for polar transforms in insight-users
> > archives, so if it is still open and if it is possible, i would be
> > pleased to submit my classes into ITK.
> >
> > Regards
> > Jakub
> >
> >
> > ------------------------------------------------------------------------
> >
> > _______________________________________________
> > Insight-users mailing list
> > Insight-users at itk.org
> > http://www.itk.org/mailman/listinfo/insight-users
>
>
>
-------------- next part --------------
#ifndef __itkCartesianToPolarTransform_h
#define __itkCartesianToPolarTransform_h
#include <iostream>
#include "itkTransform.h"
#include "itkExceptionObject.h"
#include "itkMatrix.h"
namespace itk
{
/** \brief Polar transformation of a vector space (e.g. space coordinates).
*
* Transforms first two coordinates form cartesian coordinates to polar
* coordinates <alpha,radius>. Other dimensions are left unchanges. In fact
* this is generalized cylindric transform:
* \f[ r = \sqrt{ x_1^2 + x_2^2 } \f]
* \f[ \alpha = \left\{ \begin{array}{ll}
* arccos( \frac{x_0}{x_1} ) & \mbox{$x_2 >= 0$} \\
* \mbox{2 \pi} - arccos( \frac{x_0}{x_1} ) & \mbox{$x_2 < 0$}
* \end{array}\right. \f]
* \f[ x_n = x_n, \mbox{n >= 2} \f]
*
*
* \par
* Center of the polar transform is a center of coordinate system <0,0>.
*
* Dimension must be at least 2 or an exception is thrown during transform.
*
* \author Jakub Bican, Department of Image Processing, Institute of Information Theory and Automation, Academy of Sciences of the Czech Republic.
*
* \ingroup Transforms
*/
template <
class TScalarType=double, // Data type for scalars (float or double)
unsigned int NDimensions=3> // Number of dimensions
class ITK_EXPORT CartesianToPolarTransform :
public Transform< TScalarType, NDimensions, NDimensions >
{
public:
/** Standard class typedefs. */
typedef CartesianToPolarTransform Self;
typedef Transform< TScalarType, NDimensions, NDimensions > Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** New macro for creation of through the object factory.*/
itkNewMacro( Self );
/** Run-time type information (and related methods). */
itkTypeMacro( CartesianToPolarTransform, Transform );
/** Dimension of the domain space. */
itkStaticConstMacro(SpaceDimension, unsigned int, NDimensions);
itkStaticConstMacro(ParametersDimension, unsigned int, 0); // Polar transform has no parameters
/** Standard scalar type for this class. */
typedef typename Superclass::ScalarType ScalarType;
/** Standard Jacobian container. */
typedef typename Superclass::JacobianType JacobianType;
/** Standard vector type for this class. */
typedef Vector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputVectorType;
typedef Vector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputVectorType;
/** Standard covariant vector type for this class. */
typedef CovariantVector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputCovariantVectorType;
typedef CovariantVector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputCovariantVectorType;
/** Standard vnl_vector type for this class. */
typedef vnl_vector_fixed<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputVnlVectorType;
typedef vnl_vector_fixed<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputVnlVectorType;
/** Standard coordinate point type for this class. */
typedef Point<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputPointType;
typedef Point<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputPointType;
/** Method to transform a point.
* This method transforms first two dimensions of a point from cartesian coordinates
* to polar coordinates <alpha,radius>.
*/
OutputPointType TransformPoint(const InputPointType &point ) const;
/** Method to transform a vector - not applicable for this type of transform. */
virtual OutputVectorType TransformVector(const InputVectorType &) const
{
itkExceptionMacro(<< "Method not applicable for polar transform." );
return OutputVectorType();
}
/** Method to transform a vnl_vector - not applicable for this type of transform */
virtual OutputVnlVectorType TransformVector(const InputVnlVectorType &) const
{
itkExceptionMacro(<< "Method not applicable for polar transform. ");
return OutputVnlVectorType();
}
/** Method to transform a CovariantVector - not applicable for this type of transform */
virtual OutputCovariantVectorType TransformCovariantVector(
const InputCovariantVectorType &) const
{
itkExceptionMacro(<< "Method not applicable for polar transfrom. ");
return OutputCovariantVectorType();
}
/** Compute the Jacobian Matrix of the transformation at one point - not applicable for this type of transform */
virtual const JacobianType & GetJacobian(const InputPointType &point ) const
{
itkExceptionMacro(<< "Method not applicable for polar transform. ");
return m_Jacobian;
}
protected:
CartesianToPolarTransform();
~CartesianToPolarTransform();
/** Print contents of an CartesianToPolarTransform. */
void PrintSelf(std::ostream &os, Indent indent) const;
private:
CartesianToPolarTransform(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
}; //class CartesianToPolarTransform
} // namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkCartesianToPolarTransform.txx"
#endif
#endif /* __itkCartesianToPolarTransform_h */
-------------- next part --------------
A non-text attachment was scrubbed...
Name: itkCartesianToPolarTransform.txx
Type: application/octet-stream
Size: 1424 bytes
Desc: not available
Url : http://public.kitware.com/pipermail/insight-users/attachments/20050521/7be4997a/itkCartesianToPolarTransform-0001.obj
-------------- next part --------------
#ifndef __itkComposeUniformTransformsTransform_h
#define __itkComposeUniformTransformsTransform_h
#include <iostream>
#include "itkTransform.h"
#include "itkExceptionObject.h"
#include "itkMatrix.h"
#include "itkVectorContainer.h"
namespace itk
{
/** \brief Combines transformations of a vector space (e.g. space coordinates).
*
* Iterates through a container TContainerType and successively transforms
* space coordinates of input point by each transform in the container.
*
* Transforms stored in a container MUST be derived from same type as ::Superclass,
* i.e. Transform<TScalarType,NDimensions,NDimensions> where TScalarType and NDimensions
* are same as passed into this class template. Also specified in ::TransformsType.
*
* TContainerType must conform to IndexedContainerInterface and must store transforms
* of type Transform< TScalarType, NDimensions, NDimensions >::Pointer (e.g. ::Superclass::Pointer).
*
* \author Jakub Bican, Department of Image Processing, Institute of Information Theory and Automation, Academy of Sciences of the Czech Republic.
*
* \ingroup Transforms
*/
template <
class TScalarType = double, // Data type for scalars (float or double)
unsigned int NDimensions = 3, // Number of dimensions
class TContainerType = VectorContainer< int,typename Transform<TScalarType,NDimensions,NDimensions>::Pointer > > // Transforms container type
class ITK_EXPORT ComposeUniformTransformsTransform :
public Transform< TScalarType, NDimensions, NDimensions >
{
public:
/** Standard class typedefs. */
typedef ComposeUniformTransformsTransform Self;
typedef Transform< TScalarType, NDimensions, NDimensions > Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** New macro for creation of through the object factory.*/
itkNewMacro( Self );
/** Run-time type information (and related methods). */
itkTypeMacro( ComposeUniformTransformsTransform, Transform );
/** Dimension of the domain space. */
itkStaticConstMacro(SpaceDimension, unsigned int, NDimensions);
itkStaticConstMacro(ParametersDimension, unsigned int, 0);
/** Standard scalar type for this class. */
typedef typename Superclass::ScalarType ScalarType;
/** Standard Jacobian container. */
typedef typename Superclass::JacobianType JacobianType;
/** Standard vector type for this class. */
typedef Vector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputVectorType;
typedef Vector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputVectorType;
/** Standard covariant vector type for this class. */
typedef CovariantVector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputCovariantVectorType;
typedef CovariantVector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputCovariantVectorType;
/** Standard vnl_vector type for this class. */
typedef vnl_vector_fixed<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputVnlVectorType;
typedef vnl_vector_fixed<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputVnlVectorType;
/** Standard coordinate point type for this class. */
typedef Point<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputPointType;
typedef Point<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputPointType;
/** Container type for transforms - must conform to IndexedContainerInterface */
typedef typename TContainerType ContainerType;
/** Type of transforms to compose
*
* Here, the type should be taken from ContainerType::Element. (??!!)
*
*/
typedef Transform< TScalarType, itkGetStaticConstMacro(SpaceDimension), itkGetStaticConstMacro(SpaceDimension) > TransformType;
/** Method to transform a point or a vector. */
OutputPointType TransformPoint(const InputPointType &point ) const;
virtual OutputVectorType TransformVector(const InputVectorType &) const;
virtual OutputVnlVectorType TransformVector(const InputVnlVectorType &) const;
virtual OutputCovariantVectorType TransformCovariantVector(
const InputCovariantVectorType &) const;
/** This method returns the permutation order of the PermuteAxesTransform. */
void SetTransforms(typename ContainerType::Pointer& transforms)
{ m_Transforms = transforms; }
/** This method returns the permutation order of the PermuteAxesTransform. */
const typename ContainerType::ConstPointer& GetTransforms(void) const
{ return m_Transforms; }
/** Compute the Jacobian Matrix of the transformation at one point - not applicable for this type of transform */
virtual const JacobianType & GetJacobian(const InputPointType &point ) const
{
itkExceptionMacro(<< "Method not applicable for composed transforms. ");
return m_Jacobian;
}
protected:
ComposeUniformTransformsTransform();
~ComposeUniformTransformsTransform();
/** Print contents of an TranslationTransform. */
void PrintSelf(std::ostream &os, Indent indent) const;
private:
ComposeUniformTransformsTransform(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
typename ContainerType::Pointer m_Transforms;
}; //class ComposeUniformTransformsTransform
} // namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkComposeUniformTransformsTransform.txx"
#endif
#endif /* __itkComposeUniformTransformsTransform_h */
-------------- next part --------------
A non-text attachment was scrubbed...
Name: itkComposeUniformTransformsTransform.txx
Type: application/octet-stream
Size: 3707 bytes
Desc: not available
Url : http://public.kitware.com/pipermail/insight-users/attachments/20050521/7be4997a/itkComposeUniformTransformsTransform-0001.obj
-------------- next part --------------
#ifndef __itkPermuteAxesTransform_h
#define __itkPermuteAxesTransform_h
#include <iostream>
#include "itkTransform.h"
#include "itkExceptionObject.h"
#include "itkMatrix.h"
namespace itk
{
/** \class PermuteAxesTransform
* \brief Permutes the image axes according to a user specified order.
*
* PermuateAxesTransform permutes the image axes according to a
* user specified order. The permutation order is set via method
* SetOrder( order ) where the input is an array of SpaceDimension
* number of unsigned int. The elements of the array must be a rearrangment
* of the numbers from 0 to SpaceDimension - 1.
*
* The i-th axis of the output image corresponds with the order[i]-th
* axis of the input image.
*
* \author Jakub Bican, Department of Image Processing, Institute of Information Theory and Automation, Academy of Sciences of the Czech Republic.
*
* \ingroup Transforms
*/
template <
class TScalarType=double, // Data type for scalars (float or double)
unsigned int NDimensions=3> // Number of dimensions
class ITK_EXPORT PermuteAxesTransform :
public Transform< TScalarType, NDimensions, NDimensions >
{
public:
/** Standard class typedefs. */
typedef PermuteAxesTransform Self;
typedef Transform< TScalarType, NDimensions, NDimensions > Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** New macro for creation of through the object factory.*/
itkNewMacro( Self );
/** Run-time type information (and related methods). */
itkTypeMacro( PermuteAxesTransform, Transform );
/** Dimension of the domain space. */
itkStaticConstMacro(SpaceDimension, unsigned int, NDimensions);
itkStaticConstMacro(ParametersDimension, unsigned int, 0); // Permute axes transform has no parameters
/** Standard scalar type for this class. */
typedef typename Superclass::ScalarType ScalarType;
/** Standard Jacobian container. */
typedef typename Superclass::JacobianType JacobianType;
/** Standard vector type for this class. */
typedef Vector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputVectorType;
typedef Vector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputVectorType;
/** Standard covariant vector type for this class. */
typedef CovariantVector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputCovariantVectorType;
typedef CovariantVector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputCovariantVectorType;
/** Standard vnl_vector type for this class. */
typedef vnl_vector_fixed<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputVnlVectorType;
typedef vnl_vector_fixed<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputVnlVectorType;
/** Standard coordinate point type for this class. */
typedef Point<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputPointType;
typedef Point<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputPointType;
/** Method to transform a point or a vector. */
OutputPointType TransformPoint(const InputPointType &point ) const;
OutputVectorType TransformVector(const InputVectorType &vector) const;
OutputVnlVectorType TransformVector(const InputVnlVectorType &vector) const;
OutputCovariantVectorType TransformCovariantVector(
const InputCovariantVectorType &vector) const;
/** PermuteOrderArray type. */
typedef FixedArray<unsigned int, itkGetStaticConstMacro(SpaceDimension)> PermuteOrderArrayType;
/** Set the permutation order. The elements of order must be
* a rearrangement of the numbers from 0 to (ImageDimension - 1).*/
void SetOrder( const PermuteOrderArrayType& order );
/** Returns the permutation order of the PermuteAxesTransform. */
const PermuteOrderArrayType GetOrder(void) const
{ return m_Order; }
/** Find inverse axes permutation */
bool GetInverse(Self* inverse) const;
/** Set the parameters to the IdentityTransform */
void SetIdentity(void);
/** Compute the Jacobian Matrix of the transformation at one point - not applicable for this type of transform */
virtual const JacobianType & GetJacobian(const InputPointType &point ) const
{
itkExceptionMacro(<< "Method not applicable for permute axes transform. ");
return m_Jacobian;
}
protected:
PermuteAxesTransform();
~PermuteAxesTransform();
/** Print contents of an PermuteAxesTransform. */
void PrintSelf(std::ostream &os, Indent indent) const;
private:
PermuteAxesTransform(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
PermuteOrderArrayType m_Order;
PermuteOrderArrayType m_InverseOrder;
}; //class PermuteAxesTransform
} // namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkPermuteAxesTransform.txx"
#endif
#endif /* __itkPermuteAxesTransform_h */
-------------- next part --------------
A non-text attachment was scrubbed...
Name: itkPermuteAxesTransform.txx
Type: application/octet-stream
Size: 4515 bytes
Desc: not available
Url : http://public.kitware.com/pipermail/insight-users/attachments/20050521/7be4997a/itkPermuteAxesTransform-0001.obj
-------------- next part --------------
#ifndef __itkPolarToCartesianTransform_h
#define __itkPolarToCartesianTransform_h
#include <iostream>
#include "itkTransform.h"
#include "itkExceptionObject.h"
#include "itkMatrix.h"
namespace itk
{
/** \brief Polar transformation of a vector space (e.g. space coordinates).
*
* Transforms first two coordinates form polar space <alpha,radius> to cartesian
* coordinates. Other dimensions are left unchanges. In fact this is generalized
* cylindric transform:
* \f[ x_1 = r cos( \alpha ) \f]
* \f[ x_2 = r sin( \alpha ) \f]
* \f[ x_n = x_n, \mbox{ n>=2 } \f]
*
*
* \par
* Center of the polar transform is a center of coordinate system < 0, 0 >.
*
* Dimension must be at least 2 or an exception is thrown during transform.
*
* Extent of input in first dimension (alpha) should be only < 0, 2*pi ).
*
* \author Jakub Bican, Department of Image Processing, Institute of Information Theory and Automation, Academy of Sciences of the Czech Republic.
*
* \ingroup Transforms
*/
template <
class TScalarType=double, // Data type for scalars (float or double)
unsigned int NDimensions=3> // Number of dimensions
class ITK_EXPORT PolarToCartesianTransform :
public Transform< TScalarType, NDimensions, NDimensions >
{
public:
/** Standard class typedefs. */
typedef PolarToCartesianTransform Self;
typedef Transform< TScalarType, NDimensions, NDimensions > Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** New macro for creation of through the object factory.*/
itkNewMacro( Self );
/** Run-time type information (and related methods). */
itkTypeMacro( PolarToCartesianTransform, Transform );
/** Dimension of the domain space. */
itkStaticConstMacro(SpaceDimension, unsigned int, NDimensions);
itkStaticConstMacro(ParametersDimension, unsigned int, 0); // Polar transform has no parameters
/** Standard scalar type for this class. */
typedef typename Superclass::ScalarType ScalarType;
/** Standard Jacobian container. */
typedef typename Superclass::JacobianType JacobianType;
/** Standard vector type for this class. */
typedef Vector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputVectorType;
typedef Vector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputVectorType;
/** Standard covariant vector type for this class. */
typedef CovariantVector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputCovariantVectorType;
typedef CovariantVector<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputCovariantVectorType;
/** Standard vnl_vector type for this class. */
typedef vnl_vector_fixed<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputVnlVectorType;
typedef vnl_vector_fixed<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputVnlVectorType;
/** Standard coordinate point type for this class. */
typedef Point<TScalarType, itkGetStaticConstMacro(SpaceDimension)> InputPointType;
typedef Point<TScalarType, itkGetStaticConstMacro(SpaceDimension)> OutputPointType;
/** Method to transform a point.
* This method transforms first two dimensions of a point from polar coordinates
* <alpha,radius> to cartesian coordinates.
*/
OutputPointType TransformPoint(const InputPointType &point ) const;
/** Method to transform a vector - not applicable for this type of transform. */
virtual OutputVectorType TransformVector(const InputVectorType &) const
{
itkExceptionMacro(<< "Method not applicable for polar transform." );
return OutputVectorType();
}
/** Method to transform a vnl_vector - not applicable for this type of transform */
virtual OutputVnlVectorType TransformVector(const InputVnlVectorType &) const
{
itkExceptionMacro(<< "Method not applicable for polar transform. ");
return OutputVnlVectorType();
}
/** Method to transform a CovariantVector - not applicable for this type of transform */
virtual OutputCovariantVectorType TransformCovariantVector(
const InputCovariantVectorType &) const
{
itkExceptionMacro(<< "Method not applicable for polar transfrom. ");
return OutputCovariantVectorType();
}
/** Compute the Jacobian Matrix of the transformation at one point - not applicable for this type of transform */
virtual const JacobianType & GetJacobian(const InputPointType &point ) const
{
itkExceptionMacro(<< "Method not applicable for polar transform. ");
return m_Jacobian;
}
protected:
PolarToCartesianTransform();
~PolarToCartesianTransform();
/** Print contents of an PolarToCartesianTransform. */
void PrintSelf(std::ostream &os, Indent indent) const;
private:
PolarToCartesianTransform(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
}; //class PolarToCartesianTransform
} // namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkPolarToCartesianTransform.txx"
#endif
#endif /* __itkPolarToCartesianTransform_h */
-------------- next part --------------
A non-text attachment was scrubbed...
Name: itkPolarToCartesianTransform.txx
Type: application/octet-stream
Size: 1334 bytes
Desc: not available
Url : http://public.kitware.com/pipermail/insight-users/attachments/20050521/7be4997a/itkPolarToCartesianTransform-0001.obj
More information about the Insight-users
mailing list