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
|
/*=========================================================================
*
* 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 itkRegistrationParameterScalesFromJacobian_h
#define itkRegistrationParameterScalesFromJacobian_h
#include "itkRegistrationParameterScalesEstimator.h"
namespace itk
{
/**
* \class RegistrationParameterScalesFromJacobian
* \brief Implements a registration helper class for estimating scales of
* transform parameters from Jacobian norms.
*
* Its input includes the fixed/moving images and transform objects,
* which can be obtained from the metric object.
*
* The scale of a parameter is estimated from the averaged squared norm of
* the Jacobian w.r.t the parameter. The averaging is done over a sampling
* of the image domain. The sampling by default is a uniform random
* distribution.
*
* \ingroup ITKOptimizersv4
*/
template <typename TMetric>
class ITK_TEMPLATE_EXPORT RegistrationParameterScalesFromJacobian : public RegistrationParameterScalesEstimator<TMetric>
{
public:
ITK_DISALLOW_COPY_AND_MOVE(RegistrationParameterScalesFromJacobian);
/** Standard class type aliases. */
using Self = RegistrationParameterScalesFromJacobian;
using Superclass = RegistrationParameterScalesEstimator<TMetric>;
using Pointer = SmartPointer<Self>;
using ConstPointer = SmartPointer<const Self>;
/** New macro for creation of through a Smart Pointer. */
itkNewMacro(Self);
/** \see LightObject::GetNameOfClass() */
itkOverrideGetNameOfClassMacro(RegistrationParameterScalesFromJacobian);
/** Type of scales */
using typename Superclass::ScalesType;
/** Type of parameters of the optimizer */
using typename Superclass::ParametersType;
/** Type of float */
using typename Superclass::FloatType;
using typename Superclass::VirtualPointType;
using typename Superclass::VirtualIndexType;
using typename Superclass::MovingTransformType;
using typename Superclass::FixedTransformType;
using typename Superclass::JacobianType;
using typename Superclass::VirtualImageConstPointer;
/** Estimate parameter scales from average Jacobian norms.
* For each parameter, compute the squared norm of its transform Jacobian,
* then average the squared norm over the sample points. This average is
* used as the scale of this parameter.
*/
void
EstimateScales(ScalesType & parameterScales) override;
/**
* Estimate the scale for \f$\Delta p\f$, the step of change on parameters.
* The step scale describes the impact of \f$\Delta p\f$ on the transform.
*
* Let us denote the transform by
* \f[ T(x, p) = T(x, p_0 + t * \Delta p) \f]
* where \f$x\f$ is the coordinates of a voxel, \f$p = p_0+t*\Delta p\f$ is
* the transform parameters, and \f$t\f$ is the step factor.
*
* At a specific voxel at \f$x\f$, the step scale w.r.t. \f$\Delta p\f$ is
* defined here as
*
* \f[ |\frac{dT}{dt}| = |\frac{\partial T}{\partial p} * \Delta p |. \f]
*
* For multiple voxels, we average the above formula to get the overall
* step scale.
*/
FloatType
EstimateStepScale(const ParametersType & step) override;
/** Estimate the scales of local steps. For each voxel, computes the impact
* of a step on its location as in EstimateStepScale(). Then this impact is
* attributed to the corresponding local parameters.
*/
void
EstimateLocalStepScales(const ParametersType & step, ScalesType & localStepScales) override;
protected:
RegistrationParameterScalesFromJacobian() = default;
~RegistrationParameterScalesFromJacobian() override = default;
void
PrintSelf(std::ostream & os, Indent indent) const override;
/**
* Compute the step scales for samples, i.e. the impacts on each sampled
* voxel from a change on the transform.
*/
void
ComputeSampleStepScales(const ParametersType & step, ScalesType & sampleScales);
}; // class RegistrationParameterScalesFromJacobian
} // namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
# include "itkRegistrationParameterScalesFromJacobian.hxx"
#endif
#endif /* itkRegistrationParameterScalesFromJacobian_h */
|
