Slicer  4.10
Slicer is a multi-platform, free and open source software package for visualization and medical image computing
vtkITKTransformInverse.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: $RCSfile: vtkITKTransformInverse.h,v $
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
15 
26 
27 #ifndef __vtkITKTransformInverse_h
28 #define __vtkITKTransformInverse_h
29 
30 namespace itk
31 {
32 
33  //----------------------------------------------------------------------------
34  template <typename TScalar = double, unsigned int NDimensions = 3, unsigned int VSplineOrder = 3>
36  public BSplineTransform<TScalar, NDimensions, VSplineOrder>
37  {
38  public:
41  typedef BSplineTransform<TScalar,NDimensions,VSplineOrder> Superclass;
42  typedef SmartPointer<Self> Pointer;
43  typedef SmartPointer<const Self> ConstPointer;
44 
46  itkTypeMacro( InverseBSplineTransform, BSplineTransform );
47 
49  itkNewMacro( Self );
50 
53  using Superclass::TransformPoint;
54  virtual typename Superclass::OutputPointType TransformPoint(
55  const typename Superclass::InputPointType&) const ITK_OVERRIDE
56  {
57  itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
58  }
60  const typename Superclass::InputPointType &,
61  typename Superclass::JacobianType &) const ITK_OVERRIDE
62  {
63  itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
64  }
66  const typename Superclass::InputPointType &,
67  typename Superclass::JacobianType &) const ITK_OVERRIDE
68  {
69  itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
70  }
72  const typename Superclass::InputPointType &,
73  typename Superclass::JacobianType &) const ITK_OVERRIDE
74  {
75  itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
76  }
77 
79  const typename Superclass::InputPointType &,
80  typename Superclass::WeightsType &,
81  typename Superclass::ParameterIndexArrayType &) const
82  {
83  itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
84  }
85 
86  };
87 
88  //----------------------------------------------------------------------------
89  template <typename TScalar = double, unsigned int NDimensions = 3, unsigned int VSplineOrder = 3>
91  public BSplineDeformableTransform<TScalar, NDimensions, VSplineOrder>
92  {
93  public:
96  typedef BSplineDeformableTransform<TScalar,NDimensions,VSplineOrder> Superclass;
97  typedef SmartPointer<Self> Pointer;
98  typedef SmartPointer<const Self> ConstPointer;
99 
101  itkTypeMacro( InverseBSplineDeformableTransform, BSplineDeformableTransform );
102 
104  itkNewMacro( Self );
105 
108  using Superclass::TransformPoint;
109  virtual typename Superclass::OutputPointType TransformPoint(
110  const typename Superclass::InputPointType&) const ITK_OVERRIDE
111  {
112  itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
113  }
115  const typename Superclass::InputPointType &,
116  typename Superclass::JacobianType &) const ITK_OVERRIDE
117  {
118  itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
119  }
121  const typename Superclass::InputPointType &,
122  typename Superclass::JacobianType &) const ITK_OVERRIDE
123  {
124  itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
125  }
127  const typename Superclass::InputPointType &,
128  typename Superclass::JacobianType &) const ITK_OVERRIDE
129  {
130  itkExceptionMacro( "Only storage methods are implemented for InverseBSplineTransform" );
131  }
132 
133  };
134 
135  //----------------------------------------------------------------------------
136  template <class TScalar, unsigned int NDimensions>
138  public DisplacementFieldTransform<TScalar, NDimensions>
139  {
140  public:
143  typedef DisplacementFieldTransform<TScalar, NDimensions> Superclass;
144  typedef SmartPointer<Self> Pointer;
145  typedef SmartPointer<const Self> ConstPointer;
146 
148  itkTypeMacro( InverseDisplacementFieldTransform, DisplacementFieldTransform );
149 
151  itkNewMacro( Self );
152 
155  virtual typename Superclass::OutputPointType TransformPoint(
156  const typename Superclass::InputPointType&) const ITK_OVERRIDE
157  {
158  itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
159  }
161  const typename Superclass::InputPointType &,
162  typename Superclass::JacobianType &) const ITK_OVERRIDE
163  {
164  itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
165  }
167  const typename Superclass::IndexType &,
168  typename Superclass::JacobianType &) const ITK_OVERRIDE
169  {
170  itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
171  }
173  const typename Superclass::InputPointType &,
174  typename Superclass::JacobianType &) const ITK_OVERRIDE
175  {
176  itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
177  }
179  const typename Superclass::InputPointType &,
180  typename Superclass::JacobianType &) const ITK_OVERRIDE
181  {
182  itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
183  }
185  const typename Superclass::IndexType &,
186  typename Superclass::JacobianType &) const ITK_OVERRIDE
187  {
188  itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
189  }
191  const typename Superclass::InputPointType &,
192  typename Superclass::JacobianType &,
193  bool useSVD = false ) const ITK_OVERRIDE
194  {
195  (void)useSVD; // unused
196  itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
197  }
199  const typename Superclass::IndexType &,
200  typename Superclass::JacobianType &,
201  bool useSVD = false ) const ITK_OVERRIDE
202  {
203  (void)useSVD; // unused
204  itkExceptionMacro( "Only storage methods are implemented for InverseDisplacementFieldTransform" );
205  }
206  };
207 
208  //----------------------------------------------------------------------------
209  template <class TScalar, unsigned int NDimensions>
211  public ThinPlateSplineKernelTransform<TScalar, NDimensions>
212  {
213  public:
216  typedef ThinPlateSplineKernelTransform<TScalar, NDimensions> Superclass;
217  typedef SmartPointer<Self> Pointer;
218  typedef SmartPointer<const Self> ConstPointer;
219 
221  itkTypeMacro( InverseThinPlateSplineKernelTransform, ThinPlateSplineKernelTransform );
222 
224  itkNewMacro( Self );
225 
228  virtual typename Superclass::OutputPointType TransformPoint(
229  const typename Superclass::InputPointType&) const ITK_OVERRIDE
230  {
231  itkExceptionMacro( "Only storage methods are implemented for InverseThinPlateSplineKernelTransform" );
232  }
233  virtual void ComputeDeformationContribution(const typename Superclass::InputPointType &,
234  typename Superclass::OutputPointType &) const ITK_OVERRIDE
235  {
236  itkExceptionMacro( "Only storage methods are implemented for InverseThinPlateSplineKernelTransform" );
237  }
239  const typename Superclass::InputPointType &,
240  typename Superclass::JacobianType &) const ITK_OVERRIDE
241  {
242  itkExceptionMacro( "Only storage methods are implemented for InverseThinPlateSplineKernelTransform" );
243  }
245  const typename Superclass::InputPointType &,
246  typename Superclass::JacobianType &) const ITK_OVERRIDE
247  {
248  itkExceptionMacro( "Only storage methods are implemented for InverseThinPlateSplineKernelTransform" );
249  }
251  const typename Superclass::InputPointType &,
252  typename Superclass::JacobianType &) const ITK_OVERRIDE
253  {
254  itkExceptionMacro( "Only storage methods are implemented for InverseThinPlateSplineKernelTransform" );
255  }
257  const typename Superclass::InputPointType &,
258  typename Superclass::JacobianType &,
259  bool useSVD = false ) const
260  {
261  (void)useSVD; // unused
262  itkExceptionMacro( "Only storage methods are implemented for InverseThinPlateSplineKernelTransform" );
263  }
264  };
265 
266 } // end of ITK namespace
267 
272 
275 
278 
279 #endif // __vtkITKTransformInverse_h
virtual Superclass::OutputPointType TransformPoint(const typename Superclass::InputPointType &) const ITK_OVERRIDE
SmartPointer< const Self > ConstPointer
#define itkExceptionMacro(x)
itk::InverseBSplineTransform< float, VTKDimension, BSPLINE_TRANSFORM_ORDER > InverseBSplineTransformFloatITKv4Type
virtual void ComputeJacobianWithRespectToPosition(const typename Superclass::InputPointType &, typename Superclass::JacobianType &) const ITK_OVERRIDE
virtual void ComputeJacobianWithRespectToParameters(const typename Superclass::InputPointType &, typename Superclass::JacobianType &) const ITK_OVERRIDE
virtual void ComputeInverseJacobianWithRespectToPosition(const typename Superclass::InputPointType &, typename Superclass::JacobianType &) const ITK_OVERRIDE
virtual void ComputeJacobianWithRespectToPosition(const typename Superclass::InputPointType &, typename Superclass::JacobianType &) const ITK_OVERRIDE
itk::InverseBSplineDeformableTransform< double, VTKDimension, BSPLINE_TRANSFORM_ORDER > InverseBSplineTransformDoubleITKv3Type
virtual void ComputeJacobianWithRespectToPosition(const typename Superclass::IndexType &, typename Superclass::JacobianType &) const ITK_OVERRIDE
void ComputeJacobianFromBSplineWeightsWithRespectToPosition(const typename Superclass::InputPointType &, typename Superclass::WeightsType &, typename Superclass::ParameterIndexArrayType &) const
virtual void ComputeInverseJacobianWithRespectToPosition(const typename Superclass::InputPointType &, typename Superclass::JacobianType &) const ITK_OVERRIDE
Simplified inverse ITK transforms.
itk::InverseThinPlateSplineKernelTransform< float, 3 > InverseThinPlateSplineTransformFloatType
virtual void GetInverseJacobianOfForwardFieldWithRespectToPosition(const typename Superclass::InputPointType &, typename Superclass::JacobianType &, bool useSVD=false) const
virtual void ComputeJacobianWithRespectToPosition(const typename Superclass::InputPointType &, typename Superclass::JacobianType &) const ITK_OVERRIDE
itkTypeMacro(InverseDisplacementFieldTransform, DisplacementFieldTransform)
InverseBSplineDeformableTransform Self
BSplineTransform< TScalar, NDimensions, VSplineOrder > Superclass
virtual void GetInverseJacobianOfForwardFieldWithRespectToPosition(const typename Superclass::InputPointType &, typename Superclass::JacobianType &, bool useSVD=false) const ITK_OVERRIDE
virtual void ComputeJacobianWithRespectToParameters(const typename Superclass::InputPointType &, typename Superclass::JacobianType &) const ITK_OVERRIDE
itkTypeMacro(InverseBSplineDeformableTransform, BSplineDeformableTransform)
virtual void ComputeJacobianWithRespectToParameters(const typename Superclass::InputPointType &, typename Superclass::JacobianType &) const ITK_OVERRIDE
ThinPlateSplineKernelTransform< TScalar, NDimensions > Superclass
virtual Superclass::OutputPointType TransformPoint(const typename Superclass::InputPointType &) const ITK_OVERRIDE
itk::InverseDisplacementFieldTransform< float, 3 > InverseDisplacementFieldTransformFloatType
itkTypeMacro(InverseBSplineTransform, BSplineTransform)
virtual void ComputeJacobianWithRespectToParameters(const typename Superclass::IndexType &, typename Superclass::JacobianType &) const ITK_OVERRIDE
virtual void ComputeDeformationContribution(const typename Superclass::InputPointType &, typename Superclass::OutputPointType &) const ITK_OVERRIDE
virtual void GetInverseJacobianOfForwardFieldWithRespectToPosition(const typename Superclass::IndexType &, typename Superclass::JacobianType &, bool useSVD=false) const ITK_OVERRIDE
virtual void ComputeInverseJacobianWithRespectToPosition(const typename Superclass::InputPointType &, typename Superclass::JacobianType &) const ITK_OVERRIDE
InverseThinPlateSplineKernelTransform Self
itkTypeMacro(InverseThinPlateSplineKernelTransform, ThinPlateSplineKernelTransform)
BSplineDeformableTransform< TScalar, NDimensions, VSplineOrder > Superclass
itk::InverseBSplineTransform< double, VTKDimension, BSPLINE_TRANSFORM_ORDER > InverseBSplineTransformDoubleITKv4Type
itk::InverseDisplacementFieldTransform< double, 3 > InverseDisplacementFieldTransformDoubleType
virtual void ComputeJacobianWithRespectToPosition(const typename Superclass::InputPointType &, typename Superclass::JacobianType &) const ITK_OVERRIDE
virtual void ComputeJacobianWithRespectToParameters(const typename Superclass::InputPointType &, typename Superclass::JacobianType &) const ITK_OVERRIDE
virtual Superclass::OutputPointType TransformPoint(const typename Superclass::InputPointType &) const ITK_OVERRIDE
InverseDisplacementFieldTransform Self
itk::InverseBSplineDeformableTransform< float, VTKDimension, BSPLINE_TRANSFORM_ORDER > InverseBSplineTransformFloatITKv3Type
virtual Superclass::OutputPointType TransformPoint(const typename Superclass::InputPointType &) const ITK_OVERRIDE
DisplacementFieldTransform< TScalar, NDimensions > Superclass
itk::InverseThinPlateSplineKernelTransform< double, 3 > InverseThinPlateSplineTransformDoubleType
virtual void ComputeInverseJacobianWithRespectToPosition(const typename Superclass::InputPointType &, typename Superclass::JacobianType &) const ITK_OVERRIDE