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 "itkObject.h"
 
#include "itkObjectFactory.h"
#include "itkCommand.h"
#include "itkImage.h"
#include "itkImageFileReader.h"
#include "itkImageToImageMetric.h"
 
#include "elxRegistrationBase.h"
#include "elxFixedImagePyramidBase.h"
#include "elxMovingImagePyramidBase.h"
#include "elxInterpolatorBase.h"
#include "elxImageSamplerBase.h"
#include "elxMetricBase.h"
#include "elxOptimizerBase.h"
#include "elxResamplerBase.h"
#include "elxResampleInterpolatorBase.h"
#include "elxTransformBase.h"
 
#include "itkTimeProbe.h"
 
#include <sstream>
#include <fstream>
 
#define elxGetBaseMacro( _name, _elxbasetype ) \
  virtual _elxbasetype * GetElx##_name##Base( void ) const \
  { \
    return this->GetElx##_name##Base( 0 ); \
  } \
  _elxbasetype * GetElx##_name##Base( unsigned int idx ) const \
  { \
    if( idx < this->GetNumberOf##_name##s() ) \
    { \
      return dynamic_cast< _elxbasetype * >( \
        this->Get##_name##Container()->ElementAt( idx ).GetPointer() ); \
    } \
    return 0; \
  }
//end elxGetBaseMacro
 
namespace elastix
{
 
template< class TFixedImage, class TMovingImage >
class ElastixTemplate : public itk::Object, public ElastixBase
{
public:
 
  typedef ElastixTemplate                 Self;
  typedef itk::Object                     Superclass1;
  typedef ElastixBase                     Superclass2;
  typedef itk::SmartPointer< Self >       Pointer;
  typedef itk::SmartPointer< const Self > ConstPointer;
 
  itkNewMacro( Self );
 
  itkTypeMacro( ElastixTemplate, itk::Object );
 
  typedef Superclass2::ConfigurationType          ConfigurationType;
  typedef Superclass2::ConfigurationPointer       ConfigurationPointer;
  typedef Superclass2::ObjectType                 ObjectType;                   //for the components
  typedef Superclass2::DataObjectType             DataObjectType;               //for the images
  typedef Superclass2::ObjectPointer              ObjectPointer;
  typedef Superclass2::DataObjectPointer          DataObjectPointer;
  typedef Superclass2::ObjectContainerType        ObjectContainerType;
  typedef Superclass2::DataObjectContainerType    DataObjectContainerType;
  typedef Superclass2::FileNameContainerType      FileNameContainerType;
  typedef Superclass2::ObjectContainerPointer     ObjectContainerPointer;
  typedef Superclass2::DataObjectContainerPointer DataObjectContainerPointer;
  typedef Superclass2::FileNameContainerPointer   FileNameContainerPointer;
 
  typedef TFixedImage                       FixedImageType;
  typedef TMovingImage                      MovingImageType;
  typedef typename FixedImageType::Pointer  FixedImagePointer;
  typedef typename MovingImageType::Pointer MovingImagePointer;
 
  typedef itk::DataObject ResultImageType;
 
  typedef itk::DataObject ResultDeformationFieldType;
 
  itkStaticConstMacro( Dimension,       unsigned int, FixedImageType::ImageDimension );
  itkStaticConstMacro( FixedDimension,  unsigned int, FixedImageType::ImageDimension );
  itkStaticConstMacro( MovingDimension, unsigned int, MovingImageType::ImageDimension );
 
  typedef unsigned char                                MaskPixelType;
  typedef itk::Image< MaskPixelType, FixedDimension >  FixedMaskType;
  typedef itk::Image< MaskPixelType, MovingDimension > MovingMaskType;
  typedef typename FixedMaskType::Pointer              FixedMaskPointer;
  typedef typename MovingMaskType::Pointer             MovingMaskPointer;
 
  typedef typename FixedImageType::DirectionType FixedImageDirectionType;
 
  typedef itk::CostFunction::ParametersValueType CoordRepType;   // double
 
  typedef BaseComponent BaseComponentType;
 
  typedef void (BaseComponentType::* PtrToMemberFunction)( void );
  typedef int (BaseComponentType::*  PtrToMemberFunction2)( void );
 
  typedef itk::SimpleMemberCommand< Self >                  BeforeEachResolutionCommandType;
  typedef itk::SimpleMemberCommand< Self >                  AfterEachResolutionCommandType;
  typedef itk::SimpleMemberCommand< Self >                  AfterEachIterationCommandType;
  typedef typename BeforeEachResolutionCommandType::Pointer BeforeEachResolutionCommandPointer;
  typedef typename AfterEachResolutionCommandType::Pointer  AfterEachResolutionCommandPointer;
  typedef typename AfterEachIterationCommandType::Pointer   AfterEachIterationCommandPointer;
 
  typedef FixedImagePyramidBase< Self >    FixedImagePyramidBaseType;
  typedef MovingImagePyramidBase< Self >   MovingImagePyramidBaseType;
  typedef InterpolatorBase< Self >         InterpolatorBaseType;
  typedef elx::ImageSamplerBase< Self >    ImageSamplerBaseType;
  typedef MetricBase< Self >               MetricBaseType;
  typedef OptimizerBase< Self >            OptimizerBaseType;
  typedef RegistrationBase< Self >         RegistrationBaseType;
  typedef ResamplerBase< Self >            ResamplerBaseType;
  typedef ResampleInterpolatorBase< Self > ResampleInterpolatorBaseType;
  typedef elx::TransformBase< Self >       TransformBaseType;
 
  typedef itk::TimeProbe TimerType;
 
  typedef MovingImageType InputImageType;
  typedef MovingImageType OutputImageType;
 
  typedef itk::ParameterMapInterface::ParameterMapType 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 );
 
  virtual FixedImageType * GetFixedImage( void ) const
  {
    return this->GetFixedImage( 0 );
  }
 
 
  virtual FixedImageType * GetFixedImage( unsigned int idx ) const;
 
  virtual MovingImageType * GetMovingImage( void ) const
  {
    return this->GetMovingImage( 0 );
  }
 
 
  virtual MovingImageType * GetMovingImage( unsigned int idx ) const;
 
  virtual FixedMaskType * GetFixedMask( void ) const
  {
    return this->GetFixedMask( 0 );
  }
 
 
  virtual FixedMaskType * GetFixedMask( unsigned int idx ) const;
 
  virtual MovingMaskType * GetMovingMask( void ) const
  {
    return this->GetMovingMask( 0 );
  }
 
 
  virtual MovingMaskType * GetMovingMask( unsigned int idx ) const;
 
  virtual ResultImageType * GetResultImage( void ) const
  {
    return this->GetResultImage( 0 );
  }
 
 
  virtual ResultImageType * GetResultImage( unsigned int idx ) const;
 
  virtual int SetResultImage( DataObjectPointer result_image );
 
 
  virtual ResultDeformationFieldType * GetResultDeformationField( void ) const
  {
    return this->GetResultDeformationField( 0 );
  }
 
 
  virtual ResultDeformationFieldType * GetResultDeformationField( unsigned int idx ) const;
 
  virtual int SetResultDeformationField( DataObjectPointer result_deformationfield );
 
  int Run( void ) override;
 
  int ApplyTransform( void ) override;
 
  int BeforeAll( void ) override;
 
  virtual int BeforeAllTransformix( void );
 
  void BeforeRegistration( void ) override;
 
  void BeforeEachResolution( void ) override;
 
  void AfterEachResolution( void ) override;
 
  void AfterEachIteration( void ) override;
 
  void AfterRegistration( void ) override;
 
  itkGetConstMacro( IterationCounter, unsigned int );
 
  itkGetStringMacro( CurrentTransformParameterFileName );
 
  void SetConfigurations( std::vector< ConfigurationPointer > & configurations ) override;
 
  virtual ConfigurationPointer GetConfiguration( const size_t index );
 
  virtual ConfigurationPointer GetConfiguration()
  {
    return Superclass2::GetConfiguration();
  }
 
 
  virtual bool GetOriginalFixedImageDirection( FixedImageDirectionType & direction ) const;
 
protected:
 
  ElastixTemplate();
  ~ElastixTemplate() override{}
 
  typedef typename Superclass2::MultipleImageLoader< FixedImageType >  FixedImageLoaderType;
  typedef typename Superclass2::MultipleImageLoader< MovingImageType > MovingImageLoaderType;
  typedef typename Superclass2::MultipleImageLoader< FixedMaskType >   FixedMaskLoaderType;
  typedef typename Superclass2::MultipleImageLoader< MovingMaskType >  MovingMaskLoaderType;
 
  BeforeEachResolutionCommandPointer m_BeforeEachResolutionCommand;
  AfterEachIterationCommandPointer   m_AfterEachIterationCommand;
  AfterEachResolutionCommandPointer  m_AfterEachResolutionCommand;
 
  TimerType m_Timer0;
  TimerType m_IterationTimer;
  TimerType m_ResolutionTimer;
 
  std::string m_CurrentTransformParameterFileName;
 
  std::vector< ConfigurationPointer > m_Configurations;
 
  unsigned int m_IterationCounter;
 
  virtual void CreateTransformParameterFile( const std::string FileName,
    const bool ToLog );
 
  void CreateTransformParametersMap( void ) override;
 
  ParameterMapType GetTransformParametersMap( void ) const override;
 
  ParameterMapType m_TransformParametersMap;
 
  virtual void OpenIterationInfoFile( void );
 
  std::ofstream m_IterationInfoFile;
 
  void CallInEachComponent( PtrToMemberFunction func );
 
  int CallInEachComponentInt( PtrToMemberFunction2 func );
 
  virtual void ConfigureComponents( Self * This );
 
  virtual void SetOriginalFixedImageDirection( const FixedImageDirectionType & arg );
 
private:
 
  ElastixTemplate( const Self & ); // purposely not implemented
  void operator=( const Self & );  // purposely not implemented
 
};
 
} // end namespace elastix
 
#undef elxGetBaseMacro
 
#ifndef ITK_MANUAL_INSTANTIATION
#include "elxElastixTemplate.hxx"
#endif
 
#endif // end #ifndef __elxElastixTemplate_h