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
|
/*=========================================================================
*
* Copyright UMC Utrecht and contributors
*
* 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
*
* http://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 itkTranslationTransformInitializer_h
#define itkTranslationTransformInitializer_h
// ITK header files:
#include <itkImageMomentsCalculator.h>
#include <itkObject.h>
#include <iostream>
namespace itk
{
/**
* \class TranslationTransformInitializer
*
* \brief TranslationTransformInitializer is a helper class intended to
* initialize the translation of a TranslationTransforms
*
* This class is connected to the fixed image, moving image and transform
* involved in the registration. Two modes of operation are possible:
*
* - Geometrical,
* - Center of mass
*
* In the first mode, the geometrical centers of the images are computed.
* The distance between them is set as an initial translation. This mode
* basically assumes that the anatomical objects
* to be registered are centered in their respective images. Hence the best
* initial guess for the registration is the one that superimposes those two
* centers.
*
* In the second mode, the moments of gray level values are computed
* for both images. The vector between the two centers of
* mass is passes as the initial translation to the transform. This
* second approach assumes that the moments of the anatomical objects
* are similar for both images and hence the best initial guess for
* registration is to superimpose both mass centers. Note that this
* assumption will probably not hold in multi-modality registration.
*
* \ingroup Transforms
*/
template <class TTransform, class TFixedImage, class TMovingImage>
class ITK_TEMPLATE_EXPORT TranslationTransformInitializer : public Object
{
public:
ITK_DISALLOW_COPY_AND_MOVE(TranslationTransformInitializer);
/** Standard class typedefs. */
using Self = TranslationTransformInitializer;
using Superclass = Object;
using Pointer = SmartPointer<Self>;
using ConstPointer = SmartPointer<const Self>;
/** New macro for creation of through a Smart Pointer. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(TranslationTransformInitializer, Object);
/** Type of the transform to initialize */
using TransformType = TTransform;
using TransformPointer = typename TransformType::Pointer;
/** Dimension of parameters. */
itkStaticConstMacro(SpaceDimension, unsigned int, TransformType::SpaceDimension);
itkStaticConstMacro(InputSpaceDimension, unsigned int, TransformType::InputSpaceDimension);
itkStaticConstMacro(OutputSpaceDimension, unsigned int, TransformType::OutputSpaceDimension);
/** Image Types to use in the initialization of the transform */
using FixedImageType = TFixedImage;
using MovingImageType = TMovingImage;
using FixedImagePointer = typename FixedImageType::ConstPointer;
using MovingImagePointer = typename MovingImageType::ConstPointer;
using FixedMaskType = Image<unsigned char, InputSpaceDimension>;
using MovingMaskType = Image<unsigned char, OutputSpaceDimension>;
using FixedMaskPointer = typename FixedMaskType::ConstPointer;
using MovingMaskPointer = typename MovingMaskType::ConstPointer;
/** Moment calculators */
using FixedImageCalculatorType = ImageMomentsCalculator<FixedImageType>;
using MovingImageCalculatorType = ImageMomentsCalculator<MovingImageType>;
using FixedImageCalculatorPointer = typename FixedImageCalculatorType::Pointer;
using MovingImageCalculatorPointer = typename MovingImageCalculatorType::Pointer;
/** Point type. */
using InputPointType = typename TransformType::InputPointType;
/** Vector type. */
using OutputVectorType = typename TransformType::OutputVectorType;
/** Set the transform to be initialized */
itkSetObjectMacro(Transform, TransformType);
/** Set the fixed image used in the registration process */
itkSetConstObjectMacro(FixedImage, FixedImageType);
/** Set the moving image used in the registration process */
itkSetConstObjectMacro(MovingImage, MovingImageType);
/** Set the fixed image mask used in the registration process */
itkSetConstObjectMacro(FixedMask, FixedMaskType);
/** Set the moving image mask used in the registration process */
itkSetConstObjectMacro(MovingMask, MovingMaskType);
/** Initialize the transform using data from the images */
virtual void
InitializeTransform() const;
/** Select between using the geometrical center of the images or
using the center of mass given by the image intensities. */
void
GeometryOn()
{
m_UseMoments = false;
}
void
MomentsOn()
{
m_UseMoments = true;
}
/** Get() access to the moments calculators */
itkGetConstObjectMacro(FixedCalculator, FixedImageCalculatorType);
itkGetConstObjectMacro(MovingCalculator, MovingImageCalculatorType);
protected:
TranslationTransformInitializer();
~TranslationTransformInitializer() override = default;
void
PrintSelf(std::ostream & os, Indent indent) const override;
private:
TransformPointer m_Transform{};
FixedImagePointer m_FixedImage{};
MovingImagePointer m_MovingImage{};
FixedMaskPointer m_FixedMask{};
MovingMaskPointer m_MovingMask{};
bool m_UseMoments{};
FixedImageCalculatorPointer m_FixedCalculator{};
MovingImageCalculatorPointer m_MovingCalculator{};
};
} // namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
# include "itkTranslationTransformInitializer.hxx"
#endif
#endif /* itkTranslationTransformInitializer_h */
|
