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 "itkMultiThreader.h"

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

namespace itk {

template< class TFixedImage, class TMovingImage, class TDisplacementField >
class VariationalRegistrationFilter
  : public DenseFiniteDifferenceImageFilter< TDisplacementField, TDisplacementField >
{
public:
  typedef VariationalRegistrationFilter            Self;
  typedef DenseFiniteDifferenceImageFilter<
    TDisplacementField, TDisplacementField >       Superclass;
  typedef SmartPointer< Self >                     Pointer;
  typedef SmartPointer< const Self >               ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(itkVariationalRegistrationFilter, DenseFiniteDifferenceImageFilter );

  itkStaticConstMacro(ImageDimension, unsigned int,Superclass::ImageDimension);

  typedef TFixedImage                              FixedImageType;
  typedef typename FixedImageType::Pointer         FixedImagePointer;
  typedef typename FixedImageType::ConstPointer    FixedImageConstPointer;

  typedef TMovingImage                             MovingImageType;
  typedef typename MovingImageType::Pointer        MovingImagePointer;
  typedef typename MovingImageType::ConstPointer   MovingImageConstPointer;

  typedef TDisplacementField                       DisplacementFieldType;
  typedef typename DisplacementFieldType::Pointer  DisplacementFieldPointer;

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

  typedef typename Superclass::OutputImageType     OutputImageType;

  typedef typename Superclass::TimeStepType        TimeStepType;

  typedef VariationalRegistrationFunction< FixedImageType, MovingImageType, DisplacementFieldType >
                                                   RegistrationFunctionType;
  typedef VariationalRegistrationDemonsFunction< FixedImageType, MovingImageType, DisplacementFieldType >
                                                   DefaultRegistrationFunctionType;

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

  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(); }

  virtual std::vector<SmartPointer<DataObject> >::size_type GetNumberOfValidRequiredInputs() const ITK_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() {}

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

  virtual void GenerateInputRequestedRegion() ITK_OVERRIDE;

  virtual void GenerateOutputInformation() ITK_OVERRIDE;

  virtual void CopyInputToOutput() ITK_OVERRIDE;

  virtual void Initialize() ITK_OVERRIDE;

  virtual void InitializeIteration() ITK_OVERRIDE;

  virtual void ApplyUpdate( const TimeStepType& dt ) ITK_OVERRIDE;

  virtual void VerifyInputInformation() ITK_OVERRIDE {}

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

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

private:
  VariationalRegistrationFilter(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  RegularizerPointer m_Regularizer;

  bool               m_StopRegistrationFlag;

  bool               m_SmoothDisplacementField;
  bool               m_SmoothUpdateField;

};

}// end namespace itk

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

#endif