itkVariationalRegistrationFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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 itkVariationalRegistrationFilter_h
#define itkVariationalRegistrationFilter_h

#include "itkDenseFiniteDifferenceImageFilter.h"

#include "itkVariationalRegistrationFunction.h"
#include "itkVariationalRegistrationDemonsFunction.h"
#include "itkVariationalRegistrationRegularizer.h"
#include "itkVariationalRegistrationDiffusionRegularizer.h"

namespace itk {

template< typename TFixedImage, typename TMovingImage, typename TDisplacementField >
class VariationalRegistrationFilter
  : public DenseFiniteDifferenceImageFilter< TDisplacementField, TDisplacementField >
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(VariationalRegistrationFilter);

  using Self = VariationalRegistrationFilter;
  using Superclass = DenseFiniteDifferenceImageFilter<
    TDisplacementField, TDisplacementField >;
  using Pointer = SmartPointer< Self >;
  using ConstPointer = SmartPointer< const Self >;

  itkNewMacro(Self);

  itkTypeMacro( VariationalRegistrationFilter, DenseFiniteDifferenceImageFilter );

  static constexpr unsigned int ImageDimension = Superclass::ImageDimension;

  using FixedImageType = TFixedImage;
  using FixedImagePointer = typename FixedImageType::Pointer;
  using FixedImageConstPointer = typename FixedImageType::ConstPointer;

  using MovingImageType = TMovingImage;
  using MovingImagePointer = typename MovingImageType::Pointer;
  using MovingImageConstPointer = typename MovingImageType::ConstPointer;

  using DisplacementFieldType = TDisplacementField;
  using DisplacementFieldPointer = typename DisplacementFieldType::Pointer;

  using MaskImagePixelType = unsigned char;
  using MaskImageType = Image< MaskImagePixelType, ImageDimension >;
  using MaskImagePointer = typename MaskImageType::Pointer;
  using MaskImageConstPointer = typename MaskImageType::ConstPointer;

  using OutputImageType = typename Superclass::OutputImageType;

  using TimeStepType = typename Superclass::TimeStepType;

  using RegistrationFunctionType = VariationalRegistrationFunction< FixedImageType, MovingImageType, DisplacementFieldType >;
  using DefaultRegistrationFunctionType = VariationalRegistrationDemonsFunction< FixedImageType, MovingImageType, DisplacementFieldType >;

  using RegularizerType = VariationalRegistrationRegularizer< DisplacementFieldType >;
  using RegularizerPointer = typename RegularizerType::Pointer;
  using DefaultRegularizerType = VariationalRegistrationDiffusionRegularizer< DisplacementFieldType >;

  itkSetObjectMacro( Regularizer, RegularizerType );

  itkGetConstReferenceObjectMacro( Regularizer, RegularizerType );

  virtual void SetFixedImage( const FixedImageType * ptr );

  virtual const FixedImageType * GetFixedImage(void) const;

  virtual void SetMovingImage( const MovingImageType * ptr );

  virtual const MovingImageType * GetMovingImage(void) const;

  virtual void SetMaskImage( const MaskImageType * ptr );

  virtual const MaskImageType * GetMaskImage(void) const;

  virtual void SetInitialDisplacementField( DisplacementFieldType * ptr )
    { this->SetInput( ptr ); }

  virtual DisplacementFieldType * GetDisplacementField()
    { return this->GetOutput(); }

  std::vector<SmartPointer<DataObject> >::size_type GetNumberOfValidRequiredInputs() const override;

  itkBooleanMacro( SmoothDisplacementField );

  itkSetMacro( SmoothDisplacementField, bool );

  itkGetConstMacro( SmoothDisplacementField, bool );

  itkSetMacro( SmoothUpdateField, bool );

  itkGetConstMacro( SmoothUpdateField, bool );

  itkBooleanMacro( SmoothUpdateField );

  virtual double GetMetric() const;

  virtual void StopRegistration()
    { m_StopRegistrationFlag = true; }

protected:
  VariationalRegistrationFilter();
  ~VariationalRegistrationFilter() override {}

  void PrintSelf(std::ostream& os, Indent indent) const override;

  void GenerateInputRequestedRegion() override;

  void GenerateOutputInformation() override;

  void CopyInputToOutput() override;

  void Initialize() override;

  void InitializeIteration() override;

  void ApplyUpdate( const TimeStepType& dt ) override;

  void VerifyInputInformation() const override {}

  bool Halt() override
    {  return (Superclass::Halt() || m_StopRegistrationFlag); }

  RegistrationFunctionType * DownCastDifferenceFunctionType();
  const RegistrationFunctionType * DownCastDifferenceFunctionType() const;

private:
  RegularizerPointer m_Regularizer;

  bool               m_StopRegistrationFlag;

  bool               m_SmoothDisplacementField;
  bool               m_SmoothUpdateField;

};

}// end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
# include "itkVariationalRegistrationFilter.hxx"
#endif

#endif