forked from InsightSoftwareConsortium/ITK
-
Notifications
You must be signed in to change notification settings - Fork 0
/
itkBSplineSyNImageRegistrationMethod.h
152 lines (127 loc) · 7.02 KB
/
itkBSplineSyNImageRegistrationMethod.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
/*=========================================================================
*
* Copyright Insight Software Consortium
*
* 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 itkBSplineSyNImageRegistrationMethod_h
#define itkBSplineSyNImageRegistrationMethod_h
#include "itkSyNImageRegistrationMethod.h"
#include "itkBSplineSmoothingOnUpdateDisplacementFieldTransform.h"
namespace itk
{
/** \class BSplineSyNImageRegistrationMethod
* \brief Interface method for the performing greedy B-spline SyN image registration.
*
* For greedy SyN we use \c m_Transform to map the time-parameterized middle
* image to the fixed image (and vice versa using
* \c m_Transform->GetInverseDisplacementField() ). We employ another ivar,
* \c m_InverseTransform, to map the time-parameterized middle image to the
* moving image.
*
* Output: The output is the updated transform which has been added to the
* composite transform.
*
* \author Nick Tustison
* \author Brian Avants
*
* \ingroup ITKRegistrationMethodsv4
*/
template<typename TFixedImage, typename TMovingImage, typename TOutputTransform =
BSplineSmoothingOnUpdateDisplacementFieldTransform<double, TFixedImage::ImageDimension>,
typename TVirtualImage = TFixedImage,
typename TPointSet = PointSet<unsigned int, TFixedImage::ImageDimension> >
class ITK_TEMPLATE_EXPORT BSplineSyNImageRegistrationMethod
: public SyNImageRegistrationMethod<TFixedImage, TMovingImage, TOutputTransform, TVirtualImage, TPointSet>
{
public:
ITK_DISALLOW_COPY_AND_ASSIGN(BSplineSyNImageRegistrationMethod);
/** Standard class type aliases. */
using Self = BSplineSyNImageRegistrationMethod;
using Superclass = SyNImageRegistrationMethod<TFixedImage, TMovingImage, TOutputTransform,
TVirtualImage, TPointSet>;
using Pointer = SmartPointer<Self>;
using ConstPointer = SmartPointer<const Self>;
/** Method for creation through the object factory. */
itkNewMacro( Self );
/** ImageDimension constants */
static constexpr unsigned int ImageDimension = TFixedImage::ImageDimension;
/** Run-time type information (and related methods). */
itkTypeMacro( BSplineSyNImageRegistrationMethod, SyNImageRegistrationMethod );
/** Input type alias for the images. */
using FixedImageType = TFixedImage;
using FixedImagePointer = typename FixedImageType::Pointer;
using FixedImagesContainerType = typename Superclass::FixedImagesContainerType;
using MovingImageType = TMovingImage;
using MovingImagePointer = typename MovingImageType::Pointer;
using MovingImagesContainerType = typename Superclass::MovingImagesContainerType;
using PointSetType = typename Superclass::PointSetType;
using PointSetsContainerType = typename Superclass::PointSetsContainerType;
/** Metric and transform type alias */
using ImageMetricType = typename Superclass::ImageMetricType;
using ImageMetricPointer = typename ImageMetricType::Pointer;
using MeasureType = typename ImageMetricType::MeasureType;
using ImageMaskSpatialObjectType = typename Superclass::ImageMaskSpatialObjectType;
using MaskImageType = typename ImageMaskSpatialObjectType::ImageType;
using FixedImageMaskType = typename Superclass::FixedImageMaskType;
using FixedMaskImageType = typename ImageMaskSpatialObjectType::ImageType;
using FixedImageMasksContainerType = typename Superclass::FixedImageMasksContainerType;
using MovingImageMaskType = typename Superclass::MovingImageMaskType;
using MovingMaskImageType = typename ImageMaskSpatialObjectType::ImageType;
using MovingImageMasksContainerType = typename Superclass::MovingImageMasksContainerType;
using VirtualImageType = typename Superclass::VirtualImageType;
using VirtualImageBaseType = typename Superclass::VirtualImageBaseType;
using VirtualImageBaseConstPointer = typename Superclass::VirtualImageBaseConstPointer;
using MultiMetricType = typename Superclass::MultiMetricType;
using MetricType = typename Superclass::MetricType;
using MetricPointer = typename MetricType::Pointer;
using PointSetMetricType = typename Superclass::PointSetMetricType;
using NumberOfIterationsArrayType = typename Superclass::NumberOfIterationsArrayType;
using InitialTransformType = typename Superclass::InitialTransformType;
using OutputTransformType = TOutputTransform;
using OutputTransformPointer = typename OutputTransformType::Pointer;
using RealType = typename OutputTransformType::ScalarType;
using DerivativeType = typename OutputTransformType::DerivativeType;
using DerivativeValueType = typename DerivativeType::ValueType;
using DisplacementFieldType = typename OutputTransformType::DisplacementFieldType;
using DisplacementFieldPointer = typename DisplacementFieldType::Pointer;
using DisplacementVectorType = typename DisplacementFieldType::PixelType;
using BSplineFilterType = DisplacementFieldToBSplineImageFilter<DisplacementFieldType>;
using ArrayType = typename BSplineFilterType::ArrayType;
using WeightedMaskImageType = typename BSplineFilterType::RealImageType;
using BSplinePointSetType = typename BSplineFilterType::InputPointSetType;
using CompositeTransformType = typename Superclass::CompositeTransformType;
using DisplacementFieldTransformType = typename Superclass::DisplacementFieldTransformType;
using DisplacementFieldTransformPointer = typename Superclass::DisplacementFieldTransformPointer;
using TransformBaseType = typename CompositeTransformType::TransformType;
using DecoratedOutputTransformType = typename Superclass::DecoratedOutputTransformType;
using DecoratedOutputTransformPointer = typename DecoratedOutputTransformType::Pointer;
protected:
BSplineSyNImageRegistrationMethod();
~BSplineSyNImageRegistrationMethod() override;
/** Handle optimization internally */
void StartOptimization() override;
void InitializeRegistrationAtEachLevel( const SizeValueType ) override;
DisplacementFieldPointer ComputeUpdateField( const FixedImagesContainerType, const PointSetsContainerType,
const TransformBaseType *, const MovingImagesContainerType, const PointSetsContainerType,
const TransformBaseType *, const FixedImageMasksContainerType, const MovingImageMasksContainerType,
MeasureType & ) override;
virtual DisplacementFieldPointer BSplineSmoothDisplacementField( const DisplacementFieldType *,
const ArrayType &, const WeightedMaskImageType *, const BSplinePointSetType * );
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkBSplineSyNImageRegistrationMethod.hxx"
#endif
#endif