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 "elxIterationInfo.h"
#include "elxMacro.h"
#include "elxlog.h"
 
// ITK header files:
#include <itkChangeInformationImageFilter.h>
#include <itkDataObject.h>
#include <itkImageFileReader.h>
#include <itkObject.h>
#include <itkTimeProbe.h>
#include <itkVectorContainer.h>
 
#include <fstream>
#include <iomanip>
 
#define elxGetObjectMacro(_name, _type)                                                                                \
  _type * Get##_name() const { return m_##_name.GetPointer(); }
// end elxGetObjectMacro
 
#define elxSetObjectMacro(_name, _type)                                                                                \
  void Set##_name(_type * _arg)                                                                                        \
  {                                                                                                                    \
    if (m_##_name != _arg)                                                                                             \
    {                                                                                                                  \
      m_##_name = _arg;                                                                                                \
      this->itk::Object::Modified();                                                                                   \
    }                                                                                                                  \
  }
// end elxSetObjectMacro
 
#define elxGetNumberOfMacro(_name)                                                                                     \
  unsigned int GetNumberOf##_name##s() const                                                                           \
  {                                                                                                                    \
    if (m_##_name##Container != nullptr)                                                                               \
    {                                                                                                                  \
      return m_##_name##Container->Size();                                                                             \
    }                                                                                                                  \
    return 0;                                                                                                          \
  }
// end elxGetNumberOfMacro
 
namespace elastix
{
class ElastixBase
  : public itk::Object
  , public BaseComponent
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ElastixBase);
 
  using Self = ElastixBase;
  using Superclass = BaseComponent;
 
  using ObjectPointer = itk::Object::Pointer;
  using DataObjectPointer = itk::DataObject::Pointer; // for the images
  using ObjectContainerType = itk::VectorContainer<unsigned int, ObjectPointer>;
  using ObjectContainerPointer = ObjectContainerType::Pointer;
  using DataObjectContainerType = itk::VectorContainer<unsigned int, DataObjectPointer>;
  using DataObjectContainerPointer = DataObjectContainerType::Pointer;
  using FileNameContainerType = itk::VectorContainer<unsigned int, std::string>;
  using FileNameContainerPointer = FileNameContainerType::Pointer;
 
  using ResultImageType = itk::DataObject;
 
  using ResultDeformationFieldType = itk::DataObject;
 
  using ComponentDatabasePointer = ComponentDatabase::Pointer;
  using DBIndexType = ComponentDatabase::IndexType;
  using FlatDirectionCosinesType = std::vector<double>;
 
  using CoordRepType = double; // itk::CostFunction::ParametersValueType
 
  using ParameterMapType = itk::ParameterMapInterface::ParameterMapType;
 
  elxGetObjectMacro(Configuration, Configuration);
  elxSetObjectMacro(Configuration, Configuration);
 
  void
  SetDBIndex(DBIndexType _arg);
 
  DBIndexType
  GetDBIndex()
  {
    return m_DBIndex;
  }
 
  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, itk::Object);
  elxGetObjectMacro(InitialTransform, itk::Object);
 
  elxSetObjectMacro(FinalTransform, itk::Object);
  elxGetObjectMacro(FinalTransform, itk::Object);
 
  virtual int
  Run() = 0;
 
  virtual int
  ApplyTransform(bool doReadTransform) = 0;
 
  int
  BeforeAllBase() override;
 
  int
  BeforeAllTransformixBase();
 
  ResultImageType *
  GetResultImage(const unsigned int idx = 0) const;
 
  void
  SetResultImage(DataObjectPointer result_image);
 
  ResultDeformationFieldType *
  GetResultDeformationField(unsigned int idx = 0) const;
 
  void
  SetResultDeformationField(DataObjectPointer result_deformationfield);
 
 
  bool
  GetUseDirectionCosines() const;
 
  void
  SetOriginalFixedImageDirectionFlat(const FlatDirectionCosinesType & arg);
 
  const FlatDirectionCosinesType &
  GetOriginalFixedImageDirectionFlat() const;
 
  virtual void
  CreateTransformParameterMap() = 0;
 
  ParameterMapType
  GetTransformParameterMap() const;
 
  void
  SetTransformConfigurations(const std::vector<Configuration::ConstPointer> & configurations);
 
  Configuration::ConstPointer
  GetTransformConfiguration(const size_t index) const;
 
  Configuration::ConstPointer
  GetPreviousTransformConfiguration(const Configuration & configuration) const;
 
  size_t
  GetNumberOfTransformConfigurations() const;
 
  IterationInfo &
  GetIterationInfo()
  {
    return m_IterationInfo;
  }
 
  std::ostream &
  GetIterationInfoAt(const char * const name)
  {
    return m_IterationInfo[name];
  }
 
  void
  AddTargetCellToIterationInfo(const char * const name)
  {
    m_IterationInfo.AddNewTargetCell(name);
  }
 
protected:
  ElastixBase();
  ~ElastixBase() override = default;
 
  DBIndexType m_DBIndex{ 0 };
 
  FlatDirectionCosinesType m_OriginalFixedImageDirection;
 
  itk::TimeProbe m_Timer0{};
  itk::TimeProbe m_IterationTimer{};
  itk::TimeProbe m_ResolutionTimer{};
 
  std::string m_CurrentTransformParameterFileName;
 
  unsigned int m_IterationCounter{};
 
  ParameterMapType m_TransformParameterMap;
 
  std::ofstream m_IterationInfoFile;
 
  template <class TImage>
  class ITK_TEMPLATE_EXPORT MultipleImageLoader
  {
  public:
    using DirectionType = typename TImage::DirectionType;
 
    static DataObjectContainerPointer
    GenerateImageContainer(const FileNameContainerType * const fileNameContainer,
                           const std::string &                 imageDescription,
                           bool                                useDirectionCosines,
                           DirectionType *                     originalDirectionCosines = nullptr)
    {
      const auto imageContainer = DataObjectContainerType::New();
 
      for (const auto & fileName : *fileNameContainer)
      {
        const auto infoChanger = itk::ChangeInformationImageFilter<TImage>::New();
        infoChanger->SetChangeDirection(!useDirectionCosines);
 
        try
        {
          const auto image = itk::ReadImage<TImage>(fileName);
          infoChanger->SetInput(image);
          infoChanger->Update();
 
          if (originalDirectionCosines != nullptr)
          {
            *originalDirectionCosines = image->GetDirection();
          }
        }
        catch (itk::ExceptionObject & excp)
        {
          std::string err_str = excp.GetDescription();
          err_str += "\nError occurred while reading the image described as " + imageDescription + ", with file name " +
                     fileName + "\n";
          excp.SetDescription(err_str);
          throw;
        }
 
        imageContainer->push_back(infoChanger->GetOutput());
 
 
      } // end for
 
      return imageContainer;
 
    } // end static method GenerateImageContainer
 
 
    MultipleImageLoader() = default;
    ~MultipleImageLoader() = default;
  };
 
  static DataObjectContainerPointer
  GenerateDataObjectContainer(DataObjectPointer dataObject);
 
private:
  Configuration::Pointer m_Configuration{ nullptr };
 
  std::vector<Configuration::ConstPointer> m_TransformConfigurations;
 
  IterationInfo m_IterationInfo;
 
  ObjectContainerPointer m_FixedImagePyramidContainer{ ObjectContainerType::New() };
  ObjectContainerPointer m_MovingImagePyramidContainer{ ObjectContainerType::New() };
  ObjectContainerPointer m_InterpolatorContainer{ ObjectContainerType::New() };
  ObjectContainerPointer m_ImageSamplerContainer{ ObjectContainerType::New() };
  ObjectContainerPointer m_MetricContainer{ ObjectContainerType::New() };
  ObjectContainerPointer m_OptimizerContainer{ ObjectContainerType::New() };
  ObjectContainerPointer m_RegistrationContainer{ ObjectContainerType::New() };
  ObjectContainerPointer m_ResamplerContainer{ ObjectContainerType::New() };
  ObjectContainerPointer m_ResampleInterpolatorContainer{ ObjectContainerType::New() };
  ObjectContainerPointer m_TransformContainer{ ObjectContainerType::New() };
 
  DataObjectContainerPointer m_FixedImageContainer{ DataObjectContainerType::New() };
  DataObjectContainerPointer m_MovingImageContainer{ DataObjectContainerType::New() };
  DataObjectContainerPointer m_FixedMaskContainer{ DataObjectContainerType::New() };
  DataObjectContainerPointer m_MovingMaskContainer{ DataObjectContainerType::New() };
 
  DataObjectContainerPointer m_ResultImageContainer{ DataObjectContainerType::New() };
 
  DataObjectContainerPointer m_ResultDeformationFieldContainer;
 
  FileNameContainerPointer m_FixedImageFileNameContainer{ FileNameContainerType::New() };
  FileNameContainerPointer m_MovingImageFileNameContainer{ FileNameContainerType::New() };
  FileNameContainerPointer m_FixedMaskFileNameContainer{ FileNameContainerType::New() };
  FileNameContainerPointer m_MovingMaskFileNameContainer{ FileNameContainerType::New() };
 
  ObjectPointer m_InitialTransform{ nullptr };
  ObjectPointer m_FinalTransform{ nullptr };
 
  bool m_UseDirectionCosines{ true };
};
 
} // end namespace elastix
 
#undef elxGetObjectMacro
#undef elxSetObjectMacro
#undef elxGetNumberOfMacro
 
#endif // end #ifndef elxElastixBase_h