elxElastixBase.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 __elxElastixBase_h
#define __elxElastixBase_h
 
#include "elxBaseComponent.h"
#include "elxComponentDatabase.h"
#include "elxConfiguration.h"
#include "itkObject.h"
#include "itkDataObject.h"
#include "elxMacro.h"
#include "xoutmain.h"
#include "itkVectorContainer.h"
#include "itkImageFileReader.h"
#include "itkChangeInformationImageFilter.h"
 
#include <fstream>
#include <iomanip>
 
#define elxGetObjectMacro( _name, _type ) \
  virtual _type * Get##_name( void ) const \
  { \
    return this->m_##_name.GetPointer(); \
  }
//end elxGetObjectMacro
 
#define elxSetObjectMacro( _name, _type ) \
  virtual void Set##_name( _type * _arg ) \
  { \
    if( this->m_##_name != _arg ) \
    { \
      this->m_##_name = _arg; \
      this->GetAsITKBaseType()->Modified(); \
    } \
  }
//end elxSetObjectMacro
 
#define elxGetNumberOfMacro( _name ) \
  virtual unsigned int GetNumberOf##_name##s( void ) const \
  { \
    if( this->Get##_name##Container() != nullptr ) \
    { \
      return this->Get##_name##Container()->Size(); \
    } \
    return 0; \
  }
// end elxGetNumberOfMacro
 
namespace elastix
{
class ElastixBase : public BaseComponent
{
public:
 
  typedef ElastixBase   Self;
  typedef BaseComponent Superclass;
 
  typedef Configuration              ConfigurationType;
  typedef ConfigurationType::Pointer ConfigurationPointer;
  typedef itk::Object                ObjectType;          //for the components
  typedef ObjectType::Pointer        ObjectPointer;
  typedef itk::DataObject            DataObjectType;          //for the images
  typedef DataObjectType::Pointer    DataObjectPointer;
  typedef itk::VectorContainer<
    unsigned int, ObjectPointer >              ObjectContainerType;
  typedef ObjectContainerType::Pointer ObjectContainerPointer;
  typedef itk::VectorContainer<
    unsigned int, DataObjectPointer >          DataObjectContainerType;
  typedef DataObjectContainerType::Pointer DataObjectContainerPointer;
  typedef itk::VectorContainer<
    unsigned int, std::string >               FileNameContainerType;
  typedef FileNameContainerType::Pointer FileNameContainerPointer;
 
  typedef ComponentDatabase                ComponentDatabaseType;
  typedef ComponentDatabaseType::Pointer   ComponentDatabasePointer;
  typedef ComponentDatabaseType::IndexType DBIndexType;
  typedef std::vector< double >            FlatDirectionCosinesType;
 
  typedef itk::ParameterMapInterface::ParameterMapType ParameterMapType;
 
  typedef itk::Object ITKBaseType;
 
  virtual ITKBaseType * GetAsITKBaseType( void )
  {
    return dynamic_cast< ITKBaseType * >( this );
  }
 
 
  elxGetObjectMacro( Configuration, ConfigurationType );
  elxSetObjectMacro( Configuration, ConfigurationType );
 
  virtual void SetDBIndex( DBIndexType _arg );
 
  virtual DBIndexType GetDBIndex( void )
  {
    return this->m_DBIndex;
  }
 
 
  elxGetObjectMacro( ComponentDatabase, ComponentDatabaseType );
  elxSetObjectMacro( ComponentDatabase, ComponentDatabaseType );
 
  elxGetObjectMacro( RegistrationContainer, ObjectContainerType );
  elxGetObjectMacro( FixedImagePyramidContainer, ObjectContainerType );
  elxGetObjectMacro( MovingImagePyramidContainer, ObjectContainerType );
  elxGetObjectMacro( InterpolatorContainer, ObjectContainerType );
  elxGetObjectMacro( ImageSamplerContainer, ObjectContainerType );
  elxGetObjectMacro( MetricContainer, ObjectContainerType );
  elxGetObjectMacro( OptimizerContainer, ObjectContainerType );
  elxGetObjectMacro( ResamplerContainer, ObjectContainerType );
  elxGetObjectMacro( ResampleInterpolatorContainer, ObjectContainerType );
  elxGetObjectMacro( TransformContainer, ObjectContainerType );
 
  elxSetObjectMacro( RegistrationContainer, ObjectContainerType );
  elxSetObjectMacro( FixedImagePyramidContainer, ObjectContainerType );
  elxSetObjectMacro( MovingImagePyramidContainer, ObjectContainerType );
  elxSetObjectMacro( InterpolatorContainer, ObjectContainerType );
  elxSetObjectMacro( ImageSamplerContainer, ObjectContainerType );
  elxSetObjectMacro( MetricContainer, ObjectContainerType );
  elxSetObjectMacro( OptimizerContainer, ObjectContainerType );
  elxSetObjectMacro( ResamplerContainer, ObjectContainerType );
  elxSetObjectMacro( ResampleInterpolatorContainer, ObjectContainerType );
  elxSetObjectMacro( TransformContainer, ObjectContainerType );
 
  elxGetObjectMacro( FixedImageContainer, DataObjectContainerType );
  elxGetObjectMacro( MovingImageContainer, DataObjectContainerType );
  elxSetObjectMacro( FixedImageContainer, DataObjectContainerType );
  elxSetObjectMacro( MovingImageContainer, DataObjectContainerType );
 
  elxGetObjectMacro( FixedMaskContainer, DataObjectContainerType );
  elxGetObjectMacro( MovingMaskContainer, DataObjectContainerType );
  elxSetObjectMacro( FixedMaskContainer, DataObjectContainerType );
  elxSetObjectMacro( MovingMaskContainer, DataObjectContainerType );
 
  elxGetObjectMacro( ResultImageContainer, DataObjectContainerType );
  elxSetObjectMacro( ResultImageContainer, DataObjectContainerType );
 
  elxGetObjectMacro( ResultDeformationFieldContainer, DataObjectContainerType );
  elxSetObjectMacro( ResultDeformationFieldContainer, DataObjectContainerType );
 
  elxGetObjectMacro( FixedImageFileNameContainer, FileNameContainerType );
  elxGetObjectMacro( MovingImageFileNameContainer, FileNameContainerType );
  elxSetObjectMacro( FixedImageFileNameContainer, FileNameContainerType );
  elxSetObjectMacro( MovingImageFileNameContainer, FileNameContainerType );
 
  elxGetObjectMacro( FixedMaskFileNameContainer, FileNameContainerType );
  elxGetObjectMacro( MovingMaskFileNameContainer, FileNameContainerType );
  elxSetObjectMacro( FixedMaskFileNameContainer, FileNameContainerType );
  elxSetObjectMacro( MovingMaskFileNameContainer, FileNameContainerType );
 
  elxGetNumberOfMacro( Registration );
  elxGetNumberOfMacro( FixedImagePyramid );
  elxGetNumberOfMacro( MovingImagePyramid );
  elxGetNumberOfMacro( Interpolator );
  elxGetNumberOfMacro( ImageSampler );
  elxGetNumberOfMacro( Metric );
  elxGetNumberOfMacro( Optimizer );
  elxGetNumberOfMacro( Resampler );
  elxGetNumberOfMacro( ResampleInterpolator );
  elxGetNumberOfMacro( Transform );
  elxGetNumberOfMacro( FixedImage );
  elxGetNumberOfMacro( MovingImage );
  elxGetNumberOfMacro( FixedImageFileName );
  elxGetNumberOfMacro( MovingImageFileName );
  elxGetNumberOfMacro( FixedMask );
  elxGetNumberOfMacro( MovingMask );
  elxGetNumberOfMacro( FixedMaskFileName );
  elxGetNumberOfMacro( MovingMaskFileName );
  elxGetNumberOfMacro( ResultImage );
  elxGetNumberOfMacro( ResultDeformationField );
 
  elxSetObjectMacro( InitialTransform, ObjectType );
  elxGetObjectMacro( InitialTransform, ObjectType );
 
  elxSetObjectMacro( FinalTransform, ObjectType );
  elxGetObjectMacro( FinalTransform, ObjectType );
 
  virtual int Run( void ) = 0;
 
  virtual int ApplyTransform( void ) = 0;
 
  int BeforeAllBase( void ) override;
 
  virtual int BeforeAllTransformixBase( void );
 
  void BeforeRegistrationBase( void ) override;
 
  void AfterRegistrationBase( void ) override;
 
  virtual int GetDefaultOutputPrecision( void ) const
  {
    return this->m_DefaultOutputPrecision;
  }
 
 
  virtual bool GetUseDirectionCosines( void ) const;
 
  virtual void SetOriginalFixedImageDirectionFlat(
    const FlatDirectionCosinesType & arg );
 
  virtual const FlatDirectionCosinesType & GetOriginalFixedImageDirectionFlat( void ) const;
 
  virtual void CreateTransformParametersMap( void ) = 0;
 
  virtual ParameterMapType GetTransformParametersMap( void ) const = 0;
 
  virtual void SetConfigurations( std::vector< ConfigurationPointer > & configurations ) = 0;
 
protected:
 
  ElastixBase();
  ~ElastixBase() override = default;
 
  ConfigurationPointer     m_Configuration;
  DBIndexType              m_DBIndex;
  ComponentDatabasePointer m_ComponentDatabase;
 
  FlatDirectionCosinesType m_OriginalFixedImageDirection;
 
  template< class TImage >
  class MultipleImageLoader
  {
public:
 
    typedef TImage                                         ImageType;
    typedef typename ImageType::Pointer                    ImagePointer;
    typedef itk::ImageFileReader< ImageType >              ImageReaderType;
    typedef typename ImageReaderType::Pointer              ImageReaderPointer;
    typedef typename ImageType::DirectionType              DirectionType;
    typedef itk::ChangeInformationImageFilter< ImageType > ChangeInfoFilterType;
    typedef typename ChangeInfoFilterType::Pointer         ChangeInfoFilterPointer;
 
    static DataObjectContainerPointer GenerateImageContainer(
      FileNameContainerType * fileNameContainer, const std::string & imageDescription,
      bool useDirectionCosines, DirectionType * originalDirectionCosines = nullptr )
    {
      DataObjectContainerPointer imageContainer = DataObjectContainerType::New();
 
      for( unsigned int i = 0; i < fileNameContainer->Size(); ++i )
      {
        ImageReaderPointer imageReader = ImageReaderType::New();
        imageReader->SetFileName( fileNameContainer->ElementAt( i ).c_str() );
        ChangeInfoFilterPointer infoChanger = ChangeInfoFilterType::New();
        DirectionType           direction;
        direction.SetIdentity();
        infoChanger->SetOutputDirection( direction );
        infoChanger->SetChangeDirection( !useDirectionCosines );
        infoChanger->SetInput( imageReader->GetOutput() );
 
        try
        {
          infoChanger->Update();
        }
        catch( itk::ExceptionObject & excp )
        {
          std::string err_str = excp.GetDescription();
          err_str += "\nError occurred while reading the image described as "
            + imageDescription + ", with file name " + imageReader->GetFileName() + "\n";
          excp.SetDescription( err_str );
          throw excp;
        }
 
        ImagePointer image = infoChanger->GetOutput();
        imageContainer->CreateElementAt( i ) = image.GetPointer();
 
        if( originalDirectionCosines )
        {
          *originalDirectionCosines = imageReader->GetOutput()->GetDirection();
        }
 
      } // end for i
 
      return imageContainer;
 
    } // end static method GenerateImageContainer
 
 
    static DataObjectContainerPointer GenerateImageContainer( DataObjectPointer image )
    {
      DataObjectContainerPointer imageContainer = DataObjectContainerType::New();
 
      imageContainer->CreateElementAt( 0 ) = image;
 
      return imageContainer;
 
    } // GenerateImageContainer()
 
 
    MultipleImageLoader() = default;
    ~MultipleImageLoader() = default;
 
  };
 
  class MultipleDataObjectFiller
  {
public:
 
    static DataObjectContainerPointer GenerateImageContainer(
      DataObjectPointer image )
    {
      unsigned int j = 0; //container with only one image for now
 
      DataObjectContainerPointer imageContainer = DataObjectContainerType::New();
 
      imageContainer->CreateElementAt( j ) = image;
 
      return imageContainer;
    } // end GenerateImageContainer()
 
 
    MultipleDataObjectFiller() = default;
    ~MultipleDataObjectFiller() = default;
  };
 
private:
 
  ElastixBase( const Self & );     // purposely not implemented
  void operator=( const Self & );  // purposely not implemented
 
  xl::xoutrow_type m_IterationInfo;
 
  int m_DefaultOutputPrecision;
 
  ObjectContainerPointer m_FixedImagePyramidContainer;
  ObjectContainerPointer m_MovingImagePyramidContainer;
  ObjectContainerPointer m_InterpolatorContainer;
  ObjectContainerPointer m_ImageSamplerContainer;
  ObjectContainerPointer m_MetricContainer;
  ObjectContainerPointer m_OptimizerContainer;
  ObjectContainerPointer m_RegistrationContainer;
  ObjectContainerPointer m_ResamplerContainer;
  ObjectContainerPointer m_ResampleInterpolatorContainer;
  ObjectContainerPointer m_TransformContainer;
 
  DataObjectContainerPointer m_FixedImageContainer;
  DataObjectContainerPointer m_MovingImageContainer;
  DataObjectContainerPointer m_FixedMaskContainer;
  DataObjectContainerPointer m_MovingMaskContainer;
 
  DataObjectContainerPointer m_ResultImageContainer;
 
  DataObjectContainerPointer m_ResultDeformationFieldContainer;
 
  FileNameContainerPointer m_FixedImageFileNameContainer;
  FileNameContainerPointer m_MovingImageFileNameContainer;
  FileNameContainerPointer m_FixedMaskFileNameContainer;
  FileNameContainerPointer m_MovingMaskFileNameContainer;
 
  ObjectPointer m_InitialTransform;
  ObjectPointer m_FinalTransform;
 
  bool m_UseDirectionCosines;
 
  FileNameContainerPointer GenerateFileNameContainer(
    const std::string & optionkey,
    int & errorcode,
    bool printerrors,
    bool printinfo ) const;
 
};
 
} // end namespace elastix
 
#undef elxGetObjectMacro
#undef elxSetObjectMacro
#undef elxGetNumberOfMacro
 
#endif // end #ifndef __elxElastixBase_h