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 <typename TElastix>
class ITK_TEMPLATE_EXPORT TransformBase : public BaseComponentSE<TElastix>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(TransformBase);

  using Self = TransformBase;
  using Superclass = BaseComponentSE<TElastix>;

  itkOverrideGetNameOfClassMacro(TransformBase);

  using typename Superclass::RegistrationType;
 
  using CommandLineArgumentMapType = Configuration ::CommandLineArgumentMapType;
  using CommandLineEntryType = Configuration ::CommandLineEntryType;

  using CoordinateType = ElastixBase::CoordinateType;
  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<CoordinateType, 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, CoordinateType>::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