itkElastixRegistrationMethod.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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.
 *
 *=========================================================================*/
/*=========================================================================
 *
 *  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 itkElastixRegistrationMethod_h
#define itkElastixRegistrationMethod_h
 
#include "itkImageSource.h"
#include "itkAdvancedCombinationTransform.h"
#include "itkElastixLogLevel.h"
 
#include "elxElastixMain.h"
#include "elxElastixTemplate.h"
#include "elxElastixBase.h"
#include "elxTransformBase.h"
#include "elxParameterObject.h"

 
namespace itk
{
 
template <typename TFixedImage, typename TMovingImage>
class ITK_TEMPLATE_EXPORT ElastixRegistrationMethod : public itk::ImageSource<TFixedImage>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ElastixRegistrationMethod);

  using Self = ElastixRegistrationMethod;
  using Superclass = ImageSource<TFixedImage>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkNewMacro(Self);

  itkOverrideGetNameOfClassMacro(ElastixRegistrationMethod);

  using ElastixMainType = elx::ElastixMain;
  using ElastixMainPointer = ElastixMainType::Pointer;
  using ElastixMainVectorType = std::vector<ElastixMainPointer>;
  using ElastixMainObjectPointer = ElastixMainType::ObjectPointer;
  using ArgumentMapType = ElastixMainType::ArgumentMapType;
  using ArgumentMapEntryType = ArgumentMapType::value_type;
  using FlatDirectionCosinesType = ElastixMainType::FlatDirectionCosinesType;
 
  using DataObjectContainerType = ElastixMainType::DataObjectContainerType;
  using DataObjectContainerPointer = ElastixMainType::DataObjectContainerPointer;
  using DataObjectContainerIterator = DataObjectContainerType::Iterator;
  using DataObjectIdentifierType = ProcessObject::DataObjectIdentifierType;
  using DataObjectPointerArraySizeType = ProcessObject::DataObjectPointerArraySizeType;
  using NameArrayType = ProcessObject::NameArray;
 
  using ParameterObjectType = elx::ParameterObject;
  using ParameterMapType = ParameterObjectType::ParameterMapType;
  using ParameterMapVectorType = ParameterObjectType::ParameterMapVectorType;
  using ParameterValueVectorType = ParameterObjectType::ParameterValueVectorType;
  using ParameterObjectPointer = ParameterObjectType::Pointer;
  using ParameterObjectConstPointer = ParameterObjectType::ConstPointer;
 
  static constexpr unsigned int FixedImageDimension = TFixedImage::ImageDimension;
  static constexpr unsigned int MovingImageDimension = TMovingImage::ImageDimension;
 
  static_assert(FixedImageDimension == MovingImageDimension,
                "ElastixRegistrationMethod assumes that fixed and moving image have the same number of dimensions.");
  static constexpr unsigned int ImageDimension = TFixedImage::ImageDimension;
 
  template <typename TCoordinate>
  using PointContainerType = VectorContainer<IdentifierType, Point<TCoordinate, ImageDimension>>;
 
  using FixedMaskType = Image<unsigned char, FixedImageDimension>;
  using MovingMaskType = Image<unsigned char, MovingImageDimension>;
  using TransformType = Transform<double, FixedImageDimension, MovingImageDimension>;
 
  using FixedImageType = TFixedImage;
  using MovingImageType = TMovingImage;
  using ResultImageType = FixedImageType;

  virtual void
  SetFixedImage(TFixedImage * fixedImage);
  virtual void
  AddFixedImage(TFixedImage * fixedImage);
  const FixedImageType *
  GetFixedImage() const;
  const FixedImageType *
  GetFixedImage(const unsigned int index) const;
  unsigned int
  GetNumberOfFixedImages() const;

  virtual void
  SetMovingImage(TMovingImage * movingImages);
  virtual void
  AddMovingImage(TMovingImage * movingImage);
  const MovingImageType *
  GetMovingImage() const;
  const MovingImageType *
  GetMovingImage(const unsigned int index) const;
  unsigned int
  GetNumberOfMovingImages() const;

  virtual void
  AddFixedMask(FixedMaskType * fixedMask);
  virtual void
  SetFixedMask(FixedMaskType * fixedMask);
  const FixedMaskType *
  GetFixedMask() const;
  const FixedMaskType *
  GetFixedMask(const unsigned int index) const;
  void
  RemoveFixedMask();
  unsigned int
  GetNumberOfFixedMasks() const;

  virtual void
  SetMovingMask(MovingMaskType * movingMask);
  virtual void
  AddMovingMask(MovingMaskType * movingMask);
  const MovingMaskType *
  GetMovingMask() const;
  const MovingMaskType *
  GetMovingMask(const unsigned int index) const;
  virtual void
  RemoveMovingMask();
  unsigned int
  GetNumberOfMovingMasks() const;
 
  itkSetConstObjectMacro(FixedPoints, PointContainerType<double>);
  itkSetConstObjectMacro(MovingPoints, PointContainerType<double>);
 
  void
  SetFixedPoints(const PointContainerType<float> * const points)
  {
    SetFixedPoints(ConvertToPointContainerOfDoubleCoordinates(points));
  }
 
  void
  SetMovingPoints(const PointContainerType<float> * const points)
  {
    SetMovingPoints(ConvertToPointContainerOfDoubleCoordinates(points));
  }

  virtual void
  SetParameterObject(ParameterObjectType * parameterObject);
  ParameterObjectType *
  GetParameterObject();
  const ParameterObjectType *
  GetParameterObject() const;

  ParameterObjectType *
  GetTransformParameterObject();
  const ParameterObjectType *
  GetTransformParameterObject() const;
  using Superclass::GetOutput;
  DataObject *
  GetOutput(unsigned int idx);
  const DataObject *
  GetOutput(unsigned int idx) const;
  ResultImageType *
  GetOutput();
 
  /* \note When "WriteResultImage" is false, the output image will be empty. */
  const ResultImageType *
  GetOutput() const;
 
  /* Standard filter indexed input / output methods */
  void
  SetInput(FixedImageType * fixedImage);
  const FixedImageType *
  GetInput() const;
  void
  SetInput(DataObjectPointerArraySizeType index, DataObject * input);
  const DataObject *
  GetInput(DataObjectPointerArraySizeType index) const;

  void SetInitialTransformParameterFileName(std::string);
 
  itkGetConstMacro(InitialTransformParameterFileName, std::string);
  virtual void
  RemoveInitialTransformParameterFileName()
  {
    this->SetInitialTransformParameterFileName("");
  }

  void
  SetInitialTransformParameterObject(const elx::ParameterObject *);

  const TransformType *
  GetInitialTransform() const
  {
    return m_InitialTransform;
  }

  void
  SetInitialTransform(const TransformType *);

  TransformType *
  GetExternalInitialTransform() const
  {
    return m_ExternalInitialTransform;
  }

  void
  SetExternalInitialTransform(TransformType *);

  itkSetMacro(FixedPointSetFileName, std::string);
  itkGetConstMacro(FixedPointSetFileName, std::string);
  void
  RemoveFixedPointSetFileName()
  {
    this->SetFixedPointSetFileName("");
  }

  itkSetMacro(MovingPointSetFileName, std::string);
  itkGetConstMacro(MovingPointSetFileName, std::string);
  void
  RemoveMovingPointSetFileName()
  {
    this->SetMovingPointSetFileName("");
  }

  itkSetMacro(OutputDirectory, std::string);
  itkGetConstMacro(OutputDirectory, std::string);
  void
  RemoveOutputDirectory()
  {
    this->SetOutputDirectory("");
  }

  void
  SetLogFileName(const std::string logFileName);
 
  itkGetConstMacro(LogFileName, std::string);
  void
  RemoveLogFileName();

  itkSetMacro(LogToConsole, bool);
  itkGetConstReferenceMacro(LogToConsole, bool);
  itkBooleanMacro(LogToConsole);

  itkSetMacro(LogToFile, bool);
  itkGetConstReferenceMacro(LogToFile, bool);
  itkBooleanMacro(LogToFile);

  void
  DisableOutput()
  {
    m_EnableOutput = false;
  }
 
  itkSetMacro(LogLevel, ElastixLogLevel);
  itkGetConstMacro(LogLevel, ElastixLogLevel);
 
  itkSetMacro(NumberOfThreads, int);
  itkGetConstMacro(NumberOfThreads, int);

  unsigned int
  GetNumberOfTransforms() const;

  TransformType *
  GetNthTransform(const unsigned int n) const;

  TransformType *
  GetCombinationTransform() const;

  static SmartPointer<TransformType>
  ConvertToItkTransform(const TransformType &);
 
protected:
  ElastixRegistrationMethod();
 
  void
  GenerateData() override;
 
  using DataObjectPointer = ProcessObject::DataObjectPointer;
  using Superclass::MakeOutput;
  DataObjectPointer
  MakeOutput(DataObjectPointerArraySizeType idx) override;
 
private:
  static SmartPointer<PointContainerType<double>>
  ConvertToPointContainerOfDoubleCoordinates(const PointContainerType<float> * const floatPointContainer)
  {
    if (floatPointContainer)
    {
      const auto result = PointContainerType<double>::New();
      result->assign(floatPointContainer->cbegin(), floatPointContainer->cend());
      return result;
    }
    else
    {
      return nullptr;
    }
  }

  std::string
  MakeUniqueName(const DataObjectIdentifierType & key);

  bool
  IsInputOfType(const DataObjectIdentifierType & InputOfType, const DataObjectIdentifierType & inputName) const;

  unsigned int
  GetNumberOfInputsOfType(const DataObjectIdentifierType & intputType) const;

  void
  RemoveInputsOfType(const DataObjectIdentifierType & inputName);
 

  template <typename TImage>
  std::vector<TImage *>
  GetInputImages(const char * const inputTypeString)
  {
    std::vector<TImage *> images;
    for (const auto & inputName : this->GetInputNames())
    {
      if (this->IsInputOfType(inputTypeString, inputName))
      {
        images.push_back(itkDynamicCastInDebugMode<TImage *>(this->ProcessObject::GetInput(inputName)));
      }
    }
    return images;
  }
 
  void
  ResetInitialTransformWithoutModified()
  {
    m_InitialTransform = nullptr;
    m_InitialTransformParameterFileName.clear();
    m_InitialTransformParameterObject = nullptr;
    m_ExternalInitialTransform = nullptr;
  }
 
  void
  ResetInitialTransformAndModified()
  {
    if (m_InitialTransform || m_InitialTransformParameterObject || m_ExternalInitialTransform ||
        !m_InitialTransformParameterFileName.empty())
    {
      ResetInitialTransformWithoutModified();
      this->Modified();
    }
  }

  using Superclass::SetInput;
 
  using AdvancedCombinationTransformType =
    AdvancedCombinationTransform<elx::ElastixBase::CoordinateType, FixedImageDimension>;
 
  AdvancedCombinationTransformType *
  GetAdvancedCombinationTransform() const;
 
  SmartPointer<const elx::ElastixMain> m_ElastixMain{};
 
  std::string                              m_InitialTransformParameterFileName{};
  SmartPointer<const elx::ParameterObject> m_InitialTransformParameterObject{};
  SmartPointer<const TransformType>        m_InitialTransform{};
  SmartPointer<TransformType>              m_ExternalInitialTransform{};
 
  std::string m_FixedPointSetFileName{};
  std::string m_MovingPointSetFileName{};
 
  SmartPointer<const PointContainerType<double>> m_FixedPoints{};
  SmartPointer<const PointContainerType<double>> m_MovingPoints{};
 
  std::string m_OutputDirectory{};
  std::string m_LogFileName{};
 
  bool m_EnableOutput{ true };
  bool m_LogToConsole{ false };
  bool m_LogToFile{ false };
 
  ElastixLogLevel m_LogLevel{};
 
  int m_NumberOfThreads{ 0 };
 
  unsigned int m_InputUID{ 0 };
};
 
} // namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkElastixRegistrationMethod.hxx"
#endif
 
#endif // itkElastixRegistrationMethod_h