itkMultiMetricMultiResolutionImageRegistrationMethod.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 itkMultiMetricMultiResolutionImageRegistrationMethod_h
#define itkMultiMetricMultiResolutionImageRegistrationMethod_h
 
#include "itkMultiResolutionImageRegistrationMethod2.h"
#include "itkCombinationImageToImageMetric.h"
#include <vector>
 
#define elxOverrideSimpleSetMacro(_name, _type)                                                                        \
  void Set##_name(_type _arg) override { this->Set##_name(_arg, 0); }
 
#define itkSetNumberOfMacro(_name)                                                                                     \
  virtual void SetNumberOf##_name##s(unsigned int _arg)                                                                \
  {                                                                                                                    \
    if (this->m_##_name##s.size() != _arg)                                                                             \
    {                                                                                                                  \
      this->m_##_name##s.resize(_arg);                                                                                 \
      this->Modified();                                                                                                \
    }                                                                                                                  \
  }
 
#define itkGetNumberOfMacro(_name)                                                                                     \
  virtual unsigned int GetNumberOf##_name##s() const { return this->m_##_name##s.size(); }
 
namespace itk
{
 
template <typename TFixedImage, typename TMovingImage>
class ITK_TEMPLATE_EXPORT MultiMetricMultiResolutionImageRegistrationMethod
  : public MultiResolutionImageRegistrationMethod2<TFixedImage, TMovingImage>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(MultiMetricMultiResolutionImageRegistrationMethod);
 
  using Self = MultiMetricMultiResolutionImageRegistrationMethod;
  using Superclass = MultiResolutionImageRegistrationMethod2<TFixedImage, TMovingImage>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkNewMacro(Self);
 
  itkTypeMacro(MultiMetricMultiResolutionImageRegistrationMethod, MultiResolutionImageRegistrationMethod2);
 
  using typename Superclass::FixedImageType;
  using typename Superclass::FixedImageConstPointer;
  using typename Superclass::FixedImageRegionType;
  using typename Superclass::MovingImageType;
  using typename Superclass::MovingImageConstPointer;
 
  using typename Superclass::MetricType;
  using typename Superclass::MetricPointer;
  using typename Superclass::TransformType;
  using typename Superclass::TransformPointer;
  using typename Superclass::InterpolatorType;
  using typename Superclass::InterpolatorPointer;
  using typename Superclass::OptimizerType;
  using OptimizerPointer = typename OptimizerType::Pointer;
  using typename Superclass::FixedImagePyramidType;
  using typename Superclass::FixedImagePyramidPointer;
  using typename Superclass::MovingImagePyramidType;
  using typename Superclass::MovingImagePyramidPointer;
 
  using typename Superclass::TransformOutputType;
  using typename Superclass::TransformOutputPointer;
  using typename Superclass::TransformOutputConstPointer;
 
  using typename Superclass::ParametersType;
  using typename Superclass::DataObjectPointer;
 
  using CombinationMetricType = CombinationImageToImageMetric<FixedImageType, MovingImageType>;
  using CombinationMetricPointer = typename CombinationMetricType::Pointer;
 
  virtual void
  StopMultiMetricRegistration()
  {
    this->m_Stop = true;
  }
 
 
  void
  SetMetric(MetricType * _arg) override;
 
  virtual CombinationMetricType *
  GetCombinationMetric() const
  {
    return this->m_CombinationMetric.GetPointer();
  }
 
 
  virtual void
  SetFixedImage(const FixedImageType * _arg, unsigned int pos);
 
  virtual const FixedImageType *
  GetFixedImage(unsigned int pos) const;
 
  const FixedImageType *
  GetFixedImage() const override
  {
    return this->GetFixedImage(0);
  }
 
 
  elxOverrideSimpleSetMacro(FixedImage, const FixedImageType *);
  itkSetNumberOfMacro(FixedImage);
  itkGetNumberOfMacro(FixedImage);
 
  virtual void
  SetMovingImage(const MovingImageType * _arg, unsigned int pos);
 
  virtual const MovingImageType *
  GetMovingImage(unsigned int pos) const;
 
  const MovingImageType *
  GetMovingImage() const override
  {
    return this->GetMovingImage(0);
  }
  elxOverrideSimpleSetMacro(MovingImage, const MovingImageType *);
  itkSetNumberOfMacro(MovingImage);
  itkGetNumberOfMacro(MovingImage);
 
  virtual void
  SetFixedImageRegion(FixedImageRegionType _arg, unsigned int pos);
 
  virtual const FixedImageRegionType &
  GetFixedImageRegion(unsigned int pos) const;
 
  const FixedImageRegionType &
  GetFixedImageRegion() const override
  {
    return this->GetFixedImageRegion(0);
  }
  elxOverrideSimpleSetMacro(FixedImageRegion, const FixedImageRegionType);
  itkSetNumberOfMacro(FixedImageRegion);
  itkGetNumberOfMacro(FixedImageRegion);
 
  virtual void
  SetInterpolator(InterpolatorType * _arg, unsigned int pos);
 
  virtual InterpolatorType *
  GetInterpolator(unsigned int pos) const;
 
  InterpolatorType *
  GetInterpolator() override
  {
    return this->GetInterpolator(0);
  }
 
  const InterpolatorType *
  GetInterpolator() const override
  {
    return this->GetInterpolator(0);
  }
 
  elxOverrideSimpleSetMacro(Interpolator, InterpolatorType *);
  itkSetNumberOfMacro(Interpolator);
  itkGetNumberOfMacro(Interpolator);
 
  virtual void
  SetFixedImagePyramid(FixedImagePyramidType * _arg, unsigned int pos);
 
  virtual FixedImagePyramidType *
  GetFixedImagePyramid(unsigned int pos) const;
 
  FixedImagePyramidType *
  GetFixedImagePyramid() override
  {
    return this->GetFixedImagePyramid(0);
  }
 
  const FixedImagePyramidType *
  GetFixedImagePyramid() const override
  {
    return this->GetFixedImagePyramid(0);
  }
 
  elxOverrideSimpleSetMacro(FixedImagePyramid, FixedImagePyramidType *);
  itkSetNumberOfMacro(FixedImagePyramid);
  itkGetNumberOfMacro(FixedImagePyramid);
 
  virtual void
  SetMovingImagePyramid(MovingImagePyramidType * _arg, unsigned int pos);
 
  virtual MovingImagePyramidType *
  GetMovingImagePyramid(unsigned int pos) const;
 
  MovingImagePyramidType *
  GetMovingImagePyramid() override
  {
    return this->GetMovingImagePyramid(0);
  }
 
  const MovingImagePyramidType *
  GetMovingImagePyramid() const override
  {
    return this->GetMovingImagePyramid(0);
  }
 
  elxOverrideSimpleSetMacro(MovingImagePyramid, MovingImagePyramidType *);
  itkSetNumberOfMacro(MovingImagePyramid);
  itkGetNumberOfMacro(MovingImagePyramid);
 
  ModifiedTimeType
  GetMTime() const override;
 
  const ParametersType &
  GetLastTransformParameters() const override
  {
    return this->m_LastTransformParameters;
  }
 
 
protected:
  MultiMetricMultiResolutionImageRegistrationMethod();
  ~MultiMetricMultiResolutionImageRegistrationMethod() override = default;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  using FixedImageRegionPyramidType = std::vector<FixedImageRegionType>;
 
  void
  GenerateData() override;
 
  void
  Initialize() override;
 
  virtual void
  PrepareAllPyramids();
 
  virtual void
  CheckPyramids();
 
  virtual void
  CheckOnInitialize();
 
  bool           m_Stop{};
  ParametersType m_LastTransformParameters{};
 
  CombinationMetricPointer m_CombinationMetric{};
 
  std::vector<FixedImageConstPointer>    m_FixedImages{};
  std::vector<MovingImageConstPointer>   m_MovingImages{};
  std::vector<FixedImageRegionType>      m_FixedImageRegions{};
  std::vector<FixedImagePyramidPointer>  m_FixedImagePyramids{};
  std::vector<MovingImagePyramidPointer> m_MovingImagePyramids{};
  std::vector<InterpolatorPointer>       m_Interpolators{};
 
  std::vector<FixedImageRegionPyramidType> m_FixedImageRegionPyramids{};
 
  FixedImageRegionType m_NullFixedImageRegion{};
};
 
} // end namespace itk
 
#undef itkSetNumberOfMacro
#undef itkGetNumberOfMacro
#undef elxOverrideSimpleSetMacro
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkMultiMetricMultiResolutionImageRegistrationMethod.hxx"
#endif
 
#endif