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
|
/*=========================================================================
*
* 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 itkCompositeTransformIOHelper_h
#define itkCompositeTransformIOHelper_h
#include "ITKIOTransformBaseExport.h"
#include "itkTransformIOBase.h"
#include "itkCompositeTransform.h"
namespace itk
{
/** \class CompositeTransformIOHelperTemplate
* \brief An adapter that adapts CompositeTransform into the
* TransformReader/Writer
*
* The stumbling block with fitting CompositeTransforms into
* the Transform hierarchy is that it encapsulates a list of
* itk::Transform, templated to match the dimension and scalar
* type of the CompositeTransform itself. But the Transform
* Reader/Writer uses instances of the superclass itk::TransformBase
* which is not templated.
*
* This class handles this by hiding the conversion between a list
* of TransformBase and the queue of Transform. It handles the
* conversion in a cascade of template function invocations to
* match up the transform list with the particular instantiation
* of CompositeTransform.
* \ingroup ITKIOTransformBase
*/
template <typename TParametersValueType>
class ITK_TEMPLATE_EXPORT CompositeTransformIOHelperTemplate
{
public:
using TransformType = typename TransformIOBaseTemplate<TParametersValueType>::TransformType;
using TransformPointer = typename TransformIOBaseTemplate<TParametersValueType>::TransformPointer;
using TransformListType = typename TransformIOBaseTemplate<TParametersValueType>::TransformListType;
using ConstTransformPointer = typename TransformIOBaseTemplate<TParametersValueType>::ConstTransformPointer;
using ConstTransformListType = typename TransformIOBaseTemplate<TParametersValueType>::ConstTransformListType;
/** from a composite transform, recover a
* TransformIOBase::ConstTransformList.
* This will re-build the list each time it is called, so it is best
* to call it once per CompositeTransform and access it through the
* ConstTransformListType reference, as any subsequent calls will
* rebuild the list and possibly invalidate any iterators on the
* list.
*/
ConstTransformListType &
GetTransformList(const TransformType * transform);
/** set a compositeTransform's transform list from a
** TransformIOABase::TransformList. If there is any mismatch
** between a transform being added to composite and the composite,
** this will throw an exception
*/
void
SetTransformList(TransformType * transform, TransformListType & transformList);
private:
ConstTransformListType m_TransformList;
/** Builds a list of TransformBase from the CompositeTransform's
** queue. A cascade of calls with different template parameters
** selects the correct concrete type for CompositeTransform.
*/
template <unsigned int VDimension>
int
BuildTransformList(const TransformType * transform);
/** Sets a CompositeTransform's TransformQueue from the
** TransformIO's list of TransformBase. Will throw an exception
** if the scalar type or dimension of the transform being added
** doesn't match that of the concrete CompositeTransform's type.
*/
template <unsigned int VDimension>
int
InternalSetTransformList(TransformType * transform, TransformListType & transformList);
};
/** This helps to meet backward compatibility */
using CompositeTransformIOHelper = CompositeTransformIOHelperTemplate<double>;
} // namespace itk
// Note: Explicit instantiation is done in itkCompositeTransformIOHelper.cxx
#endif // itkCompositeTransformIOHelper_h
/** Explicit instantiations */
#ifndef ITK_TEMPLATE_EXPLICIT_CompositeTransformIOHelper
// Explicit instantiation is required to ensure correct dynamic_cast
// behavior across shared libraries.
//
// IMPORTANT: Since within the same compilation unit,
// ITK_TEMPLATE_EXPLICIT_<classname> defined and undefined states
// need to be considered. This code *MUST* be *OUTSIDE* the header
// guards.
//
#if defined(ITKIOTransformBase_EXPORTS)
// We are building this library
# define ITKIOTransformBase_EXPORT_EXPLICIT ITK_FORWARD_EXPORT
#else
// We are using this library
# define ITKIOTransformBase_EXPORT_EXPLICIT ITKIOTransformBase_EXPORT
#endif
namespace itk
{
ITK_GCC_PRAGMA_DIAG_PUSH()
ITK_GCC_PRAGMA_DIAG(ignored "-Wattributes")
extern template class ITKIOTransformBase_EXPORT_EXPLICIT CompositeTransformIOHelperTemplate<double>;
extern template class ITKIOTransformBase_EXPORT_EXPLICIT CompositeTransformIOHelperTemplate<float>;
ITK_GCC_PRAGMA_DIAG_POP()
} // end namespace itk
#undef ITKIOTransformBase_EXPORT_EXPLICIT
#endif
|
