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
|
/*=========================================================================
*
* Copyright NumFOCUS
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
#ifndef itkExhaustiveOptimizerv4_h
#define itkExhaustiveOptimizerv4_h
#include "itkIntTypes.h"
#include "itkObjectToObjectOptimizerBase.h"
namespace itk
{
/**
* \class ExhaustiveOptimizerv4
* \brief Optimizer that fully samples a grid on the parametric space.
*
* This optimizer is equivalent to an exhaustive search in a discrete grid
* defined over the parametric space. The grid is centered on the initial
* position. The subdivisions of the grid along each one of the dimensions
* of the parametric space is defined by an array of number of steps.
*
* A typical use is to plot the metric space to get an idea of how noisy it
* is. An example is given below, where it is desired to plot the metric
* space with respect to translations along x, y and z in a 3D registration
* application:
* Here it is assumed that the transform is TranslationTransform.
*
\code
OptimizerType::StepsType steps( m_Transform->GetNumberOfParameters() );
steps[0] = 10;
steps[1] = 10;
steps[2] = 10;
m_Optimizer->SetNumberOfSteps( steps );
m_Optimizer->SetStepLength( 2 );
\endcode
*
* The optimizer throws IterationEvents after every iteration. We use this to plot
* the metric space in an image as follows:
*
\code
if( itk::IterationEvent().CheckEvent(& event ) )
{
IndexType index;
index[0] = m_Optimizer->GetCurrentIndex()[0];
index[1] = m_Optimizer->GetCurrentIndex()[1];
index[2] = m_Optimizer->GetCurrentIndex()[2];
image->SetPixel( index, m_Optimizer->GetCurrentValue() );
}
\endcode
*
* The image size is expected to be 11 x 11 x 11.
*
* If you wish to use different step lengths along each parametric axis,
* you can use the SetScales() method. This accepts an array, each element
* represents the number of subdivisions per step length. For instance scales
* of [0.5 1 4] along with a step length of 2 will cause the optimizer
* to search the metric space on a grid with x,y,z spacing of [1 2 8].
*
* The number of samples for each dimension of the parameter grid are
* influenced by both the scales and the number of steps along each
* dimension:
*
* parameter_samples[d] = stepLength*(2*numberOfSteps[d]+1)*scaling[d]
*
* start_parameter[d] = - stepLength * scaling[d] * numberOfSteps[d]
* end_parameter[d] = + stepLength * scaling[d] * numberOfSteps[d]
*
* \ingroup ITKOptimizersv4
*/
template <typename TInternalComputationValueType>
class ITK_TEMPLATE_EXPORT ExhaustiveOptimizerv4
: public ObjectToObjectOptimizerBaseTemplate<TInternalComputationValueType>
{
public:
ITK_DISALLOW_COPY_AND_MOVE(ExhaustiveOptimizerv4);
/** Standard "Self" type alias. */
using Self = ExhaustiveOptimizerv4;
using Superclass = ObjectToObjectOptimizerBaseTemplate<TInternalComputationValueType>;
using Pointer = SmartPointer<Self>;
using ConstPointer = SmartPointer<const Self>;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** \see LightObject::GetNameOfClass() */
itkOverrideGetNameOfClassMacro(ExhaustiveOptimizerv4);
/** Steps type */
using StepsType = Array<SizeValueType>;
/** Measure type */
using typename Superclass::MeasureType;
/** Parameters type */
using typename Superclass::ParametersType;
/** Scales type */
using typename Superclass::ScalesType;
void
StartOptimization(bool doOnlyInitialization = false) override;
/** Start optimization */
void
StartWalking();
/** Resume the optimization */
void
ResumeWalking();
/** Stop optimization */
void
StopWalking();
itkSetMacro(StepLength, double);
itkSetMacro(NumberOfSteps, StepsType);
itkGetConstReferenceMacro(StepLength, double);
itkGetConstReferenceMacro(NumberOfSteps, StepsType);
itkGetConstReferenceMacro(CurrentValue, MeasureType);
itkGetConstReferenceMacro(MaximumMetricValue, MeasureType);
itkGetConstReferenceMacro(MinimumMetricValue, MeasureType);
itkGetConstReferenceMacro(MinimumMetricValuePosition, ParametersType);
itkGetConstReferenceMacro(MaximumMetricValuePosition, ParametersType);
itkGetConstReferenceMacro(CurrentIndex, ParametersType);
/** Get the reason for termination */
const std::string
GetStopConditionDescription() const override;
/** Set the position to initialize the optimization. */
void
SetInitialPosition(const ParametersType & param);
/** Get the position to initialize the optimization. */
ParametersType &
GetInitialPosition()
{
return m_InitialPosition;
}
protected:
ExhaustiveOptimizerv4();
~ExhaustiveOptimizerv4() override = default;
void
PrintSelf(std::ostream & os, Indent indent) const override;
/** Advance to the next grid position. */
void
AdvanceOneStep();
void
IncrementIndex(ParametersType & newPosition);
protected:
ParametersType m_InitialPosition{};
MeasureType m_CurrentValue{ 0 };
StepsType m_NumberOfSteps{ 0 };
bool m_Stop{ false };
double m_StepLength{ 1.0 };
ParametersType m_CurrentIndex{ 0 };
MeasureType m_MaximumMetricValue{ 0.0 };
MeasureType m_MinimumMetricValue{ 0.0 };
ParametersType m_MinimumMetricValuePosition{};
ParametersType m_MaximumMetricValuePosition{};
private:
std::ostringstream m_StopConditionDescription{ "" };
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
# include "itkExhaustiveOptimizerv4.hxx"
#endif
#endif
|
