selxMonolithicElastix.h 6.06 KB
Newer Older
Floris Berendsen's avatar
Floris Berendsen committed
1
2
/*=========================================================================
 *
3
 *  Copyright Leiden University Medical Center, Erasmus University Medical
Floris Berendsen's avatar
Floris Berendsen committed
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 *  Center 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.
 *
 *=========================================================================*/

20
21
#ifndef selxMonolithicElastixComponent_h
#define selxMonolithicElastixComponent_h
22

23
#include "selxSuperElastixComponent.h"
24
#include "selxInterfaces.h"
25
26
#include "itkImageSource.h"

27
28
29
#include "elxElastixFilter.h"
#include "elxParameterObject.h"
#include "elxTransformixFilter.h"
30
31

#include <string.h>
32
#include "selxMacro.h"
33
34
namespace selx
{
35
36
37
38
39
40
41
42
template< int Dimensionality, class TPixel >
class MonolithicElastixComponent :
  public SuperElastixComponent<
  Accepting<
  itkImageFixedInterface< Dimensionality, TPixel >,
  itkImageMovingInterface< Dimensionality, TPixel >
  >,
  Providing<
43
  elastixTransformParameterObjectInterface< itk::Image< TPixel, Dimensionality >, itk::Image< TPixel, Dimensionality > >,
44
45
46
47
48
49
  itkImageInterface< Dimensionality, TPixel >,
  RunRegistrationInterface
  >
  >
{
public:
50

51
  selxNewMacro( MonolithicElastixComponent, ComponentBase );
52

53
  //itkStaticConstMacro(Dimensionality, unsigned int, Dimensionality);
54

55
56
  MonolithicElastixComponent();
  virtual ~MonolithicElastixComponent();
57

58
59
  typedef typename ComponentBase::CriterionType CriterionType;
  typedef TPixel                                PixelType;
60

61
62
  // the in and output image type of the component are chosen to be the same
  typedef itk::Image< PixelType, Dimensionality > ConnectionImageType;
63

64
65
66
  // fixed and moving image types are all the same, these aliases can be used to be explicit.
  typedef itk::Image< PixelType, Dimensionality > FixedImageType;
  typedef itk::Image< PixelType, Dimensionality > MovingImageType;
67

68
69
70
71
72
73
74
  typedef typename ConnectionImageType::Pointer ItkImagePointer;

  typedef elastix::ElastixFilter< FixedImageType, MovingImageType > ElastixFilterType;
  typedef elastix::ParameterObject                                  elxParameterObjectType;
  typedef elxParameterObjectType::Pointer                           elxParameterObjectPointer;

  typedef typename elastixTransformParameterObjectInterface< itk::Image< TPixel, Dimensionality >,
75
    itk::Image< TPixel, Dimensionality > >::elastixTransformParameterObject elastixTransformParameterObject;
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

  // Accepting Interfaces:
  virtual int Set( itkImageFixedInterface< Dimensionality, TPixel > * ) override;

  virtual int Set( itkImageMovingInterface< Dimensionality, TPixel > * ) override;

  // Providing Interfaces:
  virtual elastixTransformParameterObject * GetTransformParameterObject() override;

  virtual ItkImagePointer GetItkImage() override;

  virtual void RunRegistration() override;

  virtual bool MeetsCriterion( const CriterionType & criterion ) override;

  static const char * GetDescription() { return "MonolithicElastix Component"; }

private:

  typename ElastixFilterType::Pointer m_elastixFilter;

protected:

  /* The following struct returns the string name of computation type */
  /* default implementation */
101

102
  static inline const std::string GetTypeNameString()
103
  {
104
105
106
    itkGenericExceptionMacro( << "Unknown ScalarType" << typeid( TPixel ).name() );
    // TODO: provide the user instructions how to enable the compilation of the component with the required template types (if desired)
    // We might define an exception object that can communicate various error messages: for simple user, for developer user, etc
107
  }
108
109
110


  static inline const std::string GetPixelTypeNameString()
111
  {
112
113
114
    itkGenericExceptionMacro( << "Unknown PixelType" << typeid( TPixel ).name() );
    // TODO: provide the user instructions how to enable the compilation of the component with the required template types (if desired)
    // We might define an exception object that can communicate various error messages: for simple user, for developer user, etc
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
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
};

// unfortunately partial specialization of member functions is not allowed, without partially specializing the entire class.

/*
template <int Dimensionality>
class MonolithicElastixComponent < Dimensionality, double >
{
  static inline const std::string GetPixelTypeNameString();
};

template <int Dimensionality>
inline const std::string
  MonolithicElastixComponent<Dimensionality, double>
  ::GetPixelTypeNameString()
{
  return std::string("double");
}
*/

template< >
inline const std::string
MonolithicElastixComponent< 2, float >
::GetPixelTypeNameString()
{
  return std::string( "float" );
}


template< >
inline const std::string
MonolithicElastixComponent< 2, double >
::GetPixelTypeNameString()
{
  return std::string( "double" );
}


template< >
inline const std::string
MonolithicElastixComponent< 3, float >
::GetPixelTypeNameString()
{
  return std::string( "float" );
}


template< >
inline const std::string
MonolithicElastixComponent< 3, double >
::GetPixelTypeNameString()
{
  return std::string( "double" );
}


template< >
inline const std::string
MonolithicElastixComponent< 2, float >
::GetTypeNameString()
{
  return std::string( "2_float" );
}


template< >
inline const std::string
MonolithicElastixComponent< 2, double >
::GetTypeNameString()
{
  return std::string( "2_double" );
}


template< >
inline const std::string
MonolithicElastixComponent< 3, float >
::GetTypeNameString()
{
  return std::string( "3_float" );
}


template< >
inline const std::string
MonolithicElastixComponent< 3, double >
::GetTypeNameString()
{
  return std::string( "3_double" );
}
206
207
} //end namespace selx
#ifndef ITK_MANUAL_INSTANTIATION
208
#include "selxMonolithicElastix.hxx"
209
#endif
210
#endif // #define selxMonolithicElastix_h