elxTransformBase.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 elxTransformBase_h
#define elxTransformBase_h
 
#include "elxMacro.h"
 
#include "elxBaseComponentSE.h"
#include "elxDefaultConstruct.h"
#include <itkDeref.h>
#include "elxElastixBase.h"
#include "itkAdvancedTransform.h"
#include "itkAdvancedCombinationTransform.h"
#include "elxComponentDatabase.h"
#include "elxProgressCommand.h"
 
// ITK header files:
#include <itkImage.h>
#include <itkOptimizerParameters.h>
#include <itkTransformMeshFilter.h>
 
 
namespace elastix
{
// using namespace itk; //Not here, because a TransformBase class was added to ITK...
 
template <class TElastix>
class ITK_TEMPLATE_EXPORT TransformBase : public BaseComponentSE<TElastix>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(TransformBase);
 
  using Self = TransformBase;
  using Superclass = BaseComponentSE<TElastix>;
 
  itkTypeMacro(TransformBase, BaseComponentSE);
 
  using typename Superclass::RegistrationType;
 
  using CommandLineArgumentMapType = Configuration ::CommandLineArgumentMapType;
  using CommandLineEntryType = Configuration ::CommandLineEntryType;
 
  using CoordRepType = ElastixBase::CoordRepType;
  using FixedImageType = typename TElastix::FixedImageType;
  using MovingImageType = typename TElastix::MovingImageType;
 
  using ComponentDescriptionType = ComponentDatabase::ComponentDescriptionType;
  using PtrToCreator = ComponentDatabase::PtrToCreator;
 
  itkStaticConstMacro(FixedImageDimension, unsigned int, FixedImageType::ImageDimension);
 
  itkStaticConstMacro(MovingImageDimension, unsigned int, MovingImageType::ImageDimension);
 
  using CombinationTransformType = itk::AdvancedCombinationTransform<CoordRepType, Self::FixedImageDimension>;
  using ITKBaseType = CombinationTransformType;
  using InitialTransformType = typename CombinationTransformType::InitialTransformType;
 
  using ValueType = double;
  using ParametersType = itk::OptimizerParameters<ValueType>;
 
  using InputPointType = typename ITKBaseType::InputPointType;
  using OutputPointType = typename ITKBaseType::OutputPointType;
 
  using VectorPixelType = itk::Vector<float, FixedImageDimension>;
  using DeformationFieldImageType = itk::Image<VectorPixelType, FixedImageDimension>;
 
  using ITKRegistrationType = typename RegistrationType::ITKBaseType;
  using OptimizerType = typename ITKRegistrationType::OptimizerType;
  using ScalesType = itk::Optimizer::ScalesType;
 
  using SpatialJacobianDeterminantImageType = itk::Image<float, FixedImageDimension>;
  using SpatialJacobianMatrixImageType =
    itk::Image<itk::Matrix<float, MovingImageDimension, FixedImageDimension>, FixedImageDimension>;
 
 
  using ParameterMapType = typename TElastix::ParameterMapType;
 
  ITKBaseType *
  GetAsITKBaseType()
  {
    return &(this->GetSelf());
  }
 
 
  const ITKBaseType *
  GetAsITKBaseType() const
  {
    return &(this->GetSelf());
  }
 
  int
  BeforeAllTransformix();
 
  void
  SetInitialTransform(InitialTransformType * _arg);
 
  void
  SetTransformParameterFileName(const std::string & filename);
 
  virtual void
  ReadFromFile();
 
  void
  CreateTransformParameterMap(const ParametersType & param,
                              ParameterMapType &     parameterMap,
                              const bool             includeDerivedTransformParameters = true) const;
 
  void
  WriteToFile(std::ostream & transformationParameterInfo, const ParametersType & param) const;
 
  void
  SetReadWriteTransformParameters(const bool _arg);
 
  void
  ReadInitialTransformFromFile(const std::string & transformParameterFileName);
 
  void
  TransformPoints() const;
 
  typename SpatialJacobianDeterminantImageType::Pointer
  ComputeSpatialJacobianDeterminantImage() const;
 
  typename SpatialJacobianMatrixImageType::Pointer
  ComputeSpatialJacobianMatrixImage() const;
 
  void
  ComputeAndWriteSpatialJacobianDeterminantImage() const;
 
  void
  ComputeAndWriteSpatialJacobianMatrixImage() const;
 
  void
  SetFinalParameters();
 
  template <typename TMesh>
  typename TMesh::Pointer
  TransformMesh(const TMesh & mesh) const
  {
    DefaultConstruct<itk::TransformMeshFilter<TMesh, TMesh, CombinationTransformType>> transformMeshFilter;
    transformMeshFilter.SetTransform(&const_cast<CombinationTransformType &>(this->GetSelf()));
    transformMeshFilter.SetInput(&mesh);
    transformMeshFilter.Update();
    return transformMeshFilter.GetOutput();
  }
 
protected:
  TransformBase() = default;
  ~TransformBase() override = default;
 
  bool
  HasITKTransformParameters() const
  {
    const Configuration & configuration = itk::Deref(Superclass::GetConfiguration());
    return configuration.HasParameter("ITKTransformParameters");
  }
 
  void
  AutomaticScalesEstimation(ScalesType & scales) const;
 
  void
  AutomaticScalesEstimationStackTransform(const unsigned int numSubTransforms, ScalesType & scales) const;
 
private:
  elxDeclarePureVirtualGetSelfMacro(ITKBaseType);
 
  template <template <typename, typename> class TSource, typename TOutputImage>
  auto
  CreateJacobianSource() const
  {
    const auto & resampleImageFilter = *(this->m_Elastix->GetElxResamplerBase()->GetAsITKBaseType());
 
    const auto jacGenerator = TSource<TOutputImage, CoordRepType>::New();
 
    jacGenerator->SetTransform(this->GetAsITKBaseType());
    jacGenerator->SetOutputSize(resampleImageFilter.GetSize());
    jacGenerator->SetOutputSpacing(resampleImageFilter.GetOutputSpacing());
    jacGenerator->SetOutputOrigin(resampleImageFilter.GetOutputOrigin());
    jacGenerator->SetOutputIndex(resampleImageFilter.GetOutputStartIndex());
    jacGenerator->SetOutputDirection(resampleImageFilter.GetOutputDirection());
    // NOTE: We can not use the following, since the fixed image does not exist in transformix
    //   jacGenerator->SetOutputParametersFromImage(
    //     this->GetRegistration()->GetAsITKBaseType()->GetFixedImage() );
 
    return jacGenerator;
  }
 
 
  template <typename TImage>
  auto
  CreateChangeInformationImageFilter(TImage * image) const
  {
    const auto                             infoChanger = itk::ChangeInformationImageFilter<TImage>::New();
    typename FixedImageType::DirectionType originalDirection;
    const bool                             retdc = this->m_Elastix->GetOriginalFixedImageDirection(originalDirection);
    infoChanger->SetOutputDirection(originalDirection);
    infoChanger->SetChangeDirection(retdc && !this->m_Elastix->GetUseDirectionCosines());
    infoChanger->SetInput(image);
 
    return infoChanger;
  }
 
 
  void
  ReadInitialTransformFromConfiguration(const Configuration::ConstPointer);
 
  int
  BeforeAllBase() override;
 
  void
  BeforeRegistrationBase() override;
 
  void
  AfterRegistrationBase() override;
 
  const InitialTransformType *
  GetInitialTransform() const;
 
  itkGetStringMacro(TransformParameterFileName);
 
  void
  TransformPointsSomePoints(const std::string & filename) const;
 
  void
  TransformPointsSomePointsVTK(const std::string & filename) const;
 
  typename DeformationFieldImageType::Pointer
  GenerateDeformationFieldImage() const;
 
  void WriteDeformationFieldImage(typename DeformationFieldImageType::Pointer) const;
 
  void
  TransformPointsAllPoints() const;
 
  std::string
  GetInitialTransformParameterFileName() const
  {
    const InitialTransformType * const initialTransform = this->GetInitialTransform();
 
    if (!initialTransform)
    {
      return "NoInitialTransform";
    }
 
    const auto t0 = dynamic_cast<const Self *>(initialTransform);
    return t0->GetTransformParameterFileName();
  }
 
  virtual ParameterMapType
  CreateDerivedTransformParameterMap() const = 0;
 
  virtual void
  WriteDerivedTransformDataToFile() const
  {}
 
  std::string    m_TransformParameterFileName;
  ParametersType m_TransformParameters;
  ParametersType m_FinalParameters;
 
  bool m_ReadWriteTransformParameters{ true };
};
 
} // end namespace elastix
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "elxTransformBase.hxx"
#endif
 
#endif // end #ifndef elxTransformBase_h