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 "elxDefaultConstruct.h"
#include "elxIterationInfo.h"
#include "elxMacro.h"
#include "elxlog.h"
 
// ITK header files:
#include <itkChangeInformationImageFilter.h>
#include <itkDataObject.h>
#include <itkImageFileReader.h>
#include <itkMersenneTwisterRandomVariateGenerator.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 CoordinateType = 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(FixedPoints, const itk::Object);
  elxGetObjectMacro(MovingPoints, const itk::Object);
  elxSetObjectMacro(FixedPoints, const itk::Object);
  elxSetObjectMacro(MovingPoints, const itk::Object);

  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();
 
  itk::Statistics::MersenneTwisterRandomVariateGenerator &
  GetRandomVariateGenerator()
  {
    return m_RandomVariateGenerator;
  }
  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_OriginalFixedImageDirectionFlat;

  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 <typename 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() };

  itk::SmartPointer<const itk::Object> m_FixedPoints{ nullptr };
  itk::SmartPointer<const itk::Object> m_MovingPoints{ nullptr };

  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 };
 
  elx::DefaultConstruct<itk::Statistics::MersenneTwisterRandomVariateGenerator> m_RandomVariateGenerator{};
};
 
} // end namespace elastix
 
#undef elxGetObjectMacro
#undef elxSetObjectMacro
#undef elxGetNumberOfMacro
 
#endif // end #ifndef elxElastixBase_h