1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
|
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkVersorTransform.h,v $
Language: C++
Date: $Date: 2006-08-09 04:35:32 $
Version: $Revision: 1.17 $
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef __itkVersorTransform_h
#define __itkVersorTransform_h
#include <iostream>
#include "itkRigid3DTransform.h"
#include "vnl/vnl_quaternion.h"
#include "itkVersor.h"
namespace itk
{
/**
*
* VersorTransform of a vector space (e.g. space coordinates)
*
* This transform applies a rotation to the space. Rotation is about
* a user specified center.
*
* The serialization of the optimizable parameters is an array of 3 elements
* representing the right part of the versor.
*
* The serialization of the fixed parameters is an array of 3 elements defining
* the center of rotation.
*
* \TODO Need to make sure that the translation parameters in the baseclass
* cannot be set to non-zero values.
*
* \ingroup Transforms
*
**/
template < class TScalarType=double >//Data type for scalars (float or double)
class ITK_EXPORT VersorTransform : public Rigid3DTransform< TScalarType >
{
public:
/** Standard Self Typedef */
typedef VersorTransform Self;
typedef Rigid3DTransform< TScalarType > Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** Run-time type information (and related methods). */
itkTypeMacro( VersorTransform, Rigid3DTransform );
/** New macro for creation of through a Smart Pointer */
itkNewMacro( Self );
/** Dimension of parameters */
itkStaticConstMacro(SpaceDimension, unsigned int, 3);
itkStaticConstMacro(InputSpaceDimension, unsigned int, 3);
itkStaticConstMacro(OutputSpaceDimension, unsigned int, 3);
itkStaticConstMacro(ParametersDimension, unsigned int, 3);
/** Parameters Type */
typedef typename Superclass::ParametersType ParametersType;
typedef typename Superclass::JacobianType JacobianType;
typedef typename Superclass::ScalarType ScalarType;
typedef typename Superclass::InputPointType InputPointType;
typedef typename Superclass::OutputPointType OutputPointType;
typedef typename Superclass::InputVectorType InputVectorType;
typedef typename Superclass::OutputVectorType OutputVectorType;
typedef typename Superclass::InputVnlVectorType InputVnlVectorType;
typedef typename Superclass::OutputVnlVectorType OutputVnlVectorType;
typedef typename Superclass::InputCovariantVectorType
InputCovariantVectorType;
typedef typename Superclass::OutputCovariantVectorType
OutputCovariantVectorType;
typedef typename Superclass::MatrixType MatrixType;
typedef typename Superclass::InverseMatrixType InverseMatrixType;
typedef typename Superclass::CenterType CenterType;
typedef typename Superclass::OffsetType OffsetType;
/** VnlQuaternion Type */
typedef vnl_quaternion<TScalarType> VnlQuaternionType;
/** Versor Type */
typedef Versor<TScalarType> VersorType;
typedef typename VersorType::VectorType AxisType;
typedef typename VersorType::ValueType AngleType;
/**
* Set the transformation from a container of parameters
* This is typically used by optimizers.
*
* There are 3 parameters. They represent the components
* of the right part of the versor. This can be seen
* as the components of the vector parallel to the rotation
* axis and multiplied by vcl_sin( angle / 2 ). */
void SetParameters( const ParametersType & parameters );
/** Get the Transformation Parameters. */
const ParametersType& GetParameters(void) const;
/** Set the rotational part of the transform */
void SetRotation( const VersorType & versor );
void SetRotation( const AxisType & axis, AngleType angle );
itkGetConstReferenceMacro(Versor, VersorType);
/** Set the parameters to the IdentityTransform */
virtual void SetIdentity(void);
/** Compute the Jacobian of the transformation
* This method computes the Jacobian matrix of the transformation.
* given point or vector, returning the transformed point or
* vector. The rank of the Jacobian will also indicate if the
* transform is invertible at this point. */
const JacobianType & GetJacobian(const InputPointType &point ) const;
protected:
/** Construct an VersorTransform object */
VersorTransform(const MatrixType &matrix,
const OutputVectorType &offset);
VersorTransform(unsigned int outputDims,
unsigned int paramDims);
VersorTransform();
/** Destroy an VersorTransform object */
~VersorTransform(){};
/** This method must be made protected here because it is not a safe way of
* initializing the Versor */
virtual void SetRotationMatrix(const MatrixType & matrix)
{ this->Superclass::SetRotationMatrix( matrix ); }
void SetVarVersor(const VersorType & newVersor)
{ m_Versor = newVersor; }
/** Print contents of a VersorTransform */
void PrintSelf(std::ostream &os, Indent indent) const;
/** Compute Matrix
* Compute the components of the rotation matrix in the superclass */
void ComputeMatrix(void);
void ComputeMatrixParameters(void);
private:
/** Copy a VersorTransform object */
VersorTransform(const Self & other); // Not implemented
/** Assignment operator */
const Self & operator=( const Self & ); // Not implemented
/** Versor containing the rotation */
VersorType m_Versor;
}; //class VersorTransform
} // namespace itk
// Define instantiation macro for this template.
#define ITK_TEMPLATE_VersorTransform(_, EXPORT, x, y) namespace itk { \
_(1(class EXPORT VersorTransform< ITK_TEMPLATE_1 x >)) \
namespace Templates { typedef VersorTransform< ITK_TEMPLATE_1 x > VersorTransform##y; } \
}
#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkVersorTransform+-.h"
#endif
#if ITK_TEMPLATE_TXX
# include "itkVersorTransform.txx"
#endif
#endif /* __itkVersorTransform_h */
|