elxElastixTemplate.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  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 elxElastixTemplate_h
#define elxElastixTemplate_h
 
#include "elxElastixBase.h"
#include "elxFixedImagePyramidBase.h"
#include "elxImageSamplerBase.h"
#include "elxInterpolatorBase.h"
#include "elxMetricBase.h"
#include "elxMovingImagePyramidBase.h"
#include "elxOptimizerBase.h"
#include "elxRegistrationBase.h"
#include "elxResampleInterpolatorBase.h"
#include "elxResamplerBase.h"
#include "elxTransformBase.h"
 
// ITK header files:
#include <itkCommand.h>
#include <itkImage.h>
#include <itkObject.h>
 
#include <sstream>
 
#define elxGetBaseMacro(_name, _elxbasetype)                                                                           \
  _elxbasetype * GetElx##_name##Base(const unsigned int idx = 0) const                                                 \
  {                                                                                                                    \
    if (idx < this->GetNumberOf##_name##s())                                                                           \
    {                                                                                                                  \
      return dynamic_cast<_elxbasetype *>(this->Get##_name##Container()->ElementAt(idx).GetPointer());                 \
    }                                                                                                                  \
    return nullptr;                                                                                                    \
  }
// end elxGetBaseMacro
 
namespace elastix
{
 
template <class TFixedImage, class TMovingImage>
class ITK_TEMPLATE_EXPORT ElastixTemplate final : public ElastixBase
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ElastixTemplate);
 
  using Self = ElastixTemplate;
  using Superclass = ElastixBase;
  using Pointer = itk::SmartPointer<Self>;
  using ConstPointer = itk::SmartPointer<const Self>;
 
  itkNewMacro(Self);
 
  itkTypeMacro(ElastixTemplate, ElastixBase);
 
  using FixedImageType = TFixedImage;
  using MovingImageType = TMovingImage;
  using FixedImagePointer = typename FixedImageType::Pointer;
  using MovingImagePointer = typename MovingImageType::Pointer;
 
  itkStaticConstMacro(Dimension, unsigned int, FixedImageType::ImageDimension);
  itkStaticConstMacro(FixedDimension, unsigned int, FixedImageType::ImageDimension);
  itkStaticConstMacro(MovingDimension, unsigned int, MovingImageType::ImageDimension);
 
  using MaskPixelType = unsigned char;
  using FixedMaskType = itk::Image<MaskPixelType, FixedDimension>;
  using MovingMaskType = itk::Image<MaskPixelType, MovingDimension>;
  using FixedMaskPointer = typename FixedMaskType::Pointer;
  using MovingMaskPointer = typename MovingMaskType::Pointer;
 
  using FixedImageDirectionType = typename FixedImageType::DirectionType;
 
  using BaseComponentType = BaseComponent;
 
  using PtrToMemberFunction = void (BaseComponentType::*)();
  using PtrToMemberFunction2 = int (BaseComponentType::*)();
 
  using BeforeEachResolutionCommandType = itk::SimpleMemberCommand<Self>;
  using AfterEachResolutionCommandType = itk::SimpleMemberCommand<Self>;
  using AfterEachIterationCommandType = itk::SimpleMemberCommand<Self>;
  using BeforeEachResolutionCommandPointer = typename BeforeEachResolutionCommandType::Pointer;
  using AfterEachResolutionCommandPointer = typename AfterEachResolutionCommandType::Pointer;
  using AfterEachIterationCommandPointer = typename AfterEachIterationCommandType::Pointer;
 
  using FixedImagePyramidBaseType = FixedImagePyramidBase<Self>;
  using MovingImagePyramidBaseType = MovingImagePyramidBase<Self>;
  using InterpolatorBaseType = InterpolatorBase<Self>;
  using ImageSamplerBaseType = elx::ImageSamplerBase<Self>;
  using MetricBaseType = MetricBase<Self>;
  using OptimizerBaseType = OptimizerBase<Self>;
  using RegistrationBaseType = RegistrationBase<Self>;
  using ResamplerBaseType = ResamplerBase<Self>;
  using ResampleInterpolatorBaseType = ResampleInterpolatorBase<Self>;
  using TransformBaseType = elx::TransformBase<Self>;
 
  using InputImageType = MovingImageType;
  using OutputImageType = MovingImageType;
 
  using ParameterMapType = itk::ParameterMapInterface::ParameterMapType;
 
  elxGetBaseMacro(FixedImagePyramid, FixedImagePyramidBaseType);
  elxGetBaseMacro(MovingImagePyramid, MovingImagePyramidBaseType);
  elxGetBaseMacro(Interpolator, InterpolatorBaseType);
  elxGetBaseMacro(ImageSampler, ImageSamplerBaseType);
  elxGetBaseMacro(Metric, MetricBaseType);
  elxGetBaseMacro(Optimizer, OptimizerBaseType);
  elxGetBaseMacro(Registration, RegistrationBaseType);
  elxGetBaseMacro(Resampler, ResamplerBaseType);
  elxGetBaseMacro(ResampleInterpolator, ResampleInterpolatorBaseType);
  elxGetBaseMacro(Transform, TransformBaseType);
 
  FixedImageType *
  GetFixedImage(unsigned int idx = 0) const;
 
  MovingImageType *
  GetMovingImage(unsigned int idx = 0) const;
 
  FixedMaskType *
  GetFixedMask(unsigned int idx = 0) const;
 
  MovingMaskType *
  GetMovingMask(unsigned int idx = 0) const;
 
  int
  Run() override;
 
  int
  ApplyTransform(bool doReadTransform) override;
 
  int
  BeforeAll() override;
 
  int
  BeforeAllTransformix();
 
  void
  BeforeRegistration() override;
 
  void
  BeforeEachResolution() override;
 
  void
  AfterEachResolution() override;
 
  void
  AfterEachIteration() override;
 
  void
  AfterRegistration() override;
 
  itkGetConstMacro(IterationCounter, unsigned int);
 
  itkGetStringMacro(CurrentTransformParameterFileName);
 
  bool
  GetOriginalFixedImageDirection(FixedImageDirectionType & direction) const;
 
private:
  ElastixTemplate() = default;
  ~ElastixTemplate() override = default;
 
  BeforeEachResolutionCommandPointer m_BeforeEachResolutionCommand{};
  AfterEachIterationCommandPointer   m_AfterEachIterationCommand{};
  AfterEachResolutionCommandPointer  m_AfterEachResolutionCommand{};
 
  void
  CreateTransformParameterFile(const std::string & FileName, const bool ToLog);
 
  void
  CreateTransformParameterMap() override;
 
  void
  OpenIterationInfoFile();
 
  void
  CallInEachComponent(PtrToMemberFunction func);
 
  int
  CallInEachComponentInt(PtrToMemberFunction2 func);
 
  void
  ConfigureComponents(Self * This);
 
  void
  SetOriginalFixedImageDirection(const FixedImageDirectionType & arg);
};
 
} // end namespace elastix
 
#undef elxGetBaseMacro
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "elxElastixTemplate.hxx"
#endif
 
#endif // end #ifndef elxElastixTemplate_h