selxMonolithicElastix.h 6.19 KB
Newer Older
Floris Berendsen's avatar
Floris Berendsen committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*=========================================================================
 *
 *  Copyright Leiden University Medical Center, Erasmus University Medical 
 *  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
24
#include "selxComponentBase.h"
#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
35
namespace selx
{
  template <int Dimensionality, class TPixel>
36
  class MonolithicElastixComponent : 
37
    public SuperElastixComponent<
38
      Accepting< 
39
40
        itkImageFixedInterface<Dimensionality, TPixel>,
        itkImageMovingInterface<Dimensionality, TPixel>
41
      >,
42
43
      Providing<
        elastixTransformParameterObjectInterface<itk::Image<TPixel, Dimensionality>, itk::Image<TPixel, Dimensionality>>,
44
        itkImageInterface<Dimensionality, TPixel>, 
45
46
47
48
49
        RunRegistrationInterface
      >
    >
  {
  public:
50
    selxNewMacro(MonolithicElastixComponent, ComponentBase);
51

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

54
55
    MonolithicElastixComponent();
    virtual ~MonolithicElastixComponent();
56
57
    
    typedef typename ComponentBase::CriterionType CriterionType;
58
59
60
61
62
63
64
65
66
    typedef TPixel PixelType;

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

    // 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
    typedef typename ConnectionImageType::Pointer ItkImagePointer;

69
70
71
    typedef elastix::ElastixFilter< FixedImageType, MovingImageType > ElastixFilterType;
    typedef elastix::ParameterObject elxParameterObjectType;
    typedef elxParameterObjectType::Pointer elxParameterObjectPointer;
Floris Berendsen's avatar
Floris Berendsen committed
72
    
73
    typedef typename elastixTransformParameterObjectInterface<itk::Image<TPixel, Dimensionality>, itk::Image<TPixel, Dimensionality>>::elastixTransformParameterObject elastixTransformParameterObject;
74
75
    
    // Accepting Interfaces:
76
77
    virtual int Set(itkImageFixedInterface<Dimensionality, TPixel>*) override;
    virtual int Set(itkImageMovingInterface<Dimensionality, TPixel>*) override;
78
    
79
80
    // Providing Interfaces:
    virtual elastixTransformParameterObject* GetTransformParameterObject() override;
81
    virtual ItkImagePointer GetItkImage() override;
82
83
84
    virtual void RunRegistration() override;

    virtual bool MeetsCriterion(const CriterionType &criterion) override;
85
    static const char * GetDescription() { return "MonolithicElastix Component"; };
86
  private:
87
    typename ElastixFilterType::Pointer m_elastixFilter;
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
  protected:
    /* The following struct returns the string name of computation type */
    /* default implementation */

    static inline const std::string GetTypeNameString()
    {
      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
    }

    static inline const std::string GetPixelTypeNameString()
    {
      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
    }

  };

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

  /*
  template <int Dimensionality>
112
  class MonolithicElastixComponent < Dimensionality, double >
113
114
115
116
117
118
  {
    static inline const std::string GetPixelTypeNameString();
  };

  template <int Dimensionality>
  inline const std::string
119
    MonolithicElastixComponent<Dimensionality, double>
120
121
122
123
124
125
126
127
    ::GetPixelTypeNameString()
  {
    return std::string("double");
  }
  */

  template <>
  inline const std::string
128
    MonolithicElastixComponent<2, float>
129
130
131
132
133
134
135
136
    ::GetPixelTypeNameString()
  {
    return std::string("float");
  }


  template <>
  inline const std::string
137
    MonolithicElastixComponent<2, double>
138
139
140
141
142
143
144
    ::GetPixelTypeNameString()
  {
    return std::string("double");
  }

  template <>
  inline const std::string
145
    MonolithicElastixComponent<3, float>
146
147
148
149
150
151
152
    ::GetPixelTypeNameString()
  {
    return std::string("float");
  }

  template <>
  inline const std::string
153
    MonolithicElastixComponent<3, double>
154
155
156
157
158
159
    ::GetPixelTypeNameString()
  {
    return std::string("double");
  }
  template <>
  inline const std::string
160
    MonolithicElastixComponent<2, float>
161
162
163
164
165
166
167
    ::GetTypeNameString()
  {
    return std::string("2_float");
  }

  template <>
  inline const std::string
168
    MonolithicElastixComponent<2, double>
169
170
171
172
173
174
175
    ::GetTypeNameString()
  {
    return std::string("2_double");
  }

  template <>
  inline const std::string
176
    MonolithicElastixComponent<3,float>
177
178
179
180
181
182
183
    ::GetTypeNameString()
  {
    return std::string("3_float");
  }
  
  template <>
  inline const std::string
184
    MonolithicElastixComponent<3,double>
185
186
187
188
189
190
    ::GetTypeNameString()
  {
    return std::string("3_double");
  }
} //end namespace selx
#ifndef ITK_MANUAL_INSTANTIATION
191
#include "selxMonolithicElastix.hxx"
192
#endif
193
#endif // #define selxMonolithicElastix_h