-
Notifications
You must be signed in to change notification settings - Fork 16
/
itkMeshToMeshRegistrationMethod.h
196 lines (153 loc) · 7.31 KB
/
itkMeshToMeshRegistrationMethod.h
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
184
185
186
187
188
189
190
191
192
193
194
195
196
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile: itkMeshToMeshRegistrationMethod.h,v $
Language: C++
Date: $Date: 2006-06-08 20:30:47 $
Version: $Revision: 1.2 $
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 __itkMeshToMeshRegistrationMethod_h
#define __itkMeshToMeshRegistrationMethod_h
#include "itkProcessObject.h"
#include "itkMeshToMeshMetric.h"
#include "itkSingleValuedNonLinearOptimizer.h"
#include "itkDataObjectDecorator.h"
namespace itk
{
/** \class MeshToMeshRegistrationMethod
* \brief Base class for Mesh to Mesh Registration Methods
*
* This Class define the generic interface for a registration method.
*
* This class is templated over the type of the Mesh and the Mesh to be
* registered. A generic Transform is used by this class. That allows to select
* at run time the particular type of transformation that is to be applied for
* registering the Meshs.
*
* This method use a generic Metric in order to compare the Mesh and the
* Mesh. The final goal of the registration method is to find the set of
* parameters of the Transformation that optimizes the metric.
*
* The registration method also support a generic optimizer that can be
* selected at run-time. The only restriction for the optimizer is that it
* should be able to operate in single-valued cost functions given that the
* metrics used to compare Mesh with Meshes provide a single value as
* output.
*
* The terms : FixedMesh and MovingMesh are used in this class to indicate
* that the Mesh is being mapped by the transform.
*
* This class uses the coordinate system of the Fixed Mesh as a reference
* and searchs for a Transform that will map points from the space of the Fixed
* Mesh to the space of the Moving Mesh.
*
* For doing so, a Metric will be continously applied to compare the Fixed
* Mesh with the Transformed Moving Mesh. This process also requires to
* interpolate values from the Moving Mesh.
*
* \ingroup RegistrationFilters
*/
template <typename TFixedMesh, typename TMovingMesh>
class ITK_EXPORT MeshToMeshRegistrationMethod : public ProcessObject
{
public:
/** Standard class typedefs. */
typedef MeshToMeshRegistrationMethod Self;
typedef ProcessObject Superclass;
typedef SmartPointer<Self> Pointer;
typedef SmartPointer<const Self> ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(MeshToMeshRegistrationMethod, ProcessObject);
/** Type of the Fixed Mesh. */
typedef TFixedMesh FixedMeshType;
typedef typename FixedMeshType::ConstPointer FixedMeshConstPointer;
/** Type of the Moving Mesh. */
typedef TMovingMesh MovingMeshType;
typedef typename MovingMeshType::ConstPointer MovingMeshConstPointer;
/** Type of the metric. */
typedef MeshToMeshMetric< FixedMeshType,
MovingMeshType > MetricType;
typedef typename MetricType::Pointer MetricPointer;
/** Type of the Transform . */
typedef typename MetricType::TransformType TransformType;
typedef typename TransformType::Pointer TransformPointer;
/** Type of the Interpolator. */
typedef typename MetricType::InterpolatorType InterpolatorType;
typedef typename InterpolatorType::Pointer InterpolatorPointer;
/** Type for the output: Using Decorator pattern for enabling
* the Transform to be passed in the data pipeline */
typedef DataObjectDecorator< TransformType > TransformOutputType;
typedef typename TransformOutputType::Pointer TransformOutputPointer;
typedef typename TransformOutputType::ConstPointer TransformOutputConstPointer;
/** Type of the optimizer. */
typedef SingleValuedNonLinearOptimizer OptimizerType;
/** Type of the Transformation parameters This is the same type used to
* represent the search space of the optimization algorithm */
typedef typename MetricType::TransformParametersType ParametersType;
/** Smart Pointer type to a DataObject. */
typedef typename DataObject::Pointer DataObjectPointer;
/** Set/Get the Fixed Mesh. */
itkSetConstObjectMacro( FixedMesh, FixedMeshType );
itkGetConstObjectMacro( FixedMesh, FixedMeshType );
/** Set/Get the Moving Mesh. */
itkSetConstObjectMacro( MovingMesh, MovingMeshType );
itkGetConstObjectMacro( MovingMesh, MovingMeshType );
/** Set/Get the Optimizer. */
itkSetObjectMacro( Optimizer, OptimizerType );
itkGetConstObjectMacro( Optimizer, OptimizerType );
/** Set/Get the Metric. */
itkSetObjectMacro( Metric, MetricType );
itkGetConstObjectMacro( Metric, MetricType );
/** Set/Get the Transfrom. */
itkSetObjectMacro( Transform, TransformType );
itkGetConstObjectMacro( Transform, TransformType );
/** Set/Get the Interpolator. */
itkSetObjectMacro( Interpolator, InterpolatorType );
itkGetConstObjectMacro( Interpolator, InterpolatorType );
/** Set/Get the initial transformation parameters. */
virtual void SetInitialTransformParameters( const ParametersType & param );
itkGetConstReferenceMacro( InitialTransformParameters, ParametersType );
/** Get the last transformation parameters visited by
* the optimizer. */
itkGetConstReferenceMacro( LastTransformParameters, ParametersType );
/** Initialize by setting the interconnects between the components. */
void Initialize() throw (ExceptionObject);
/** Returns the transform resulting from the registration process */
const TransformOutputType * GetOutput() const;
using Superclass::MakeOutput;
/** Make a DataObject of the correct type to be used as the specified
* output. */
virtual DataObjectPointer MakeOutput(size_t idx);
/** Method to return the latest modified time of this object or
* any of its cached ivars */
unsigned long GetMTime() const;
protected:
MeshToMeshRegistrationMethod();
virtual ~MeshToMeshRegistrationMethod() {};
void PrintSelf(std::ostream& os, Indent indent) const;
/** Method invoked by the pipeline in order to trigger the computation of
* the registration. */
void GenerateData ();
private:
MeshToMeshRegistrationMethod(const Self&); //purposely not implemented
void operator=(const Self&); //purposely not implemented
MetricPointer m_Metric;
OptimizerType::Pointer m_Optimizer;
MovingMeshConstPointer m_MovingMesh;
FixedMeshConstPointer m_FixedMesh;
TransformPointer m_Transform;
InterpolatorPointer m_Interpolator;
ParametersType m_InitialTransformParameters;
ParametersType m_LastTransformParameters;
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkMeshToMeshRegistrationMethod.hxx"
#endif
#endif