mitkPyramidImageRegistrationMethod.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#ifndef MITKPYRAMIDIMAGEREGISTRATION_H
#define MITKPYRAMIDIMAGEREGISTRATION_H

#include <MitkDiffusionCoreExports.h>

#include <itkObject.h>
#include "itkImageMaskSpatialObject.h"
#include "itkNotImageFilter.h"
#include <itkCenteredVersorTransformInitializer.h>
#include <vnl/vnl_matrix_fixed.h>

#include "mitkImage.h"
#include "mitkBaseProcess.h"

#include "mitkPyramidRegistrationMethodHelper.h"
#include <itkWindowedSincInterpolateImageFunction.h>

#include "mitkImageToItk.h"
#include "mitkImageCast.h"
#include "mitkImageCaster.h"
#include "mitkITKImageImport.h"
#include "mitkIOUtil.h"


namespace mitk
{

class MITKDIFFUSIONCORE_EXPORT PyramidImageRegistrationMethod :
    public itk::Object
{
public:

  mitkClassMacroItkParent(PyramidImageRegistrationMethod, itk::Object)

  
  itkFactorylessNewMacro(Self)
  itkCloneMacro(Self)

  typedef itk::OptimizerParameters<double> ParametersType;

  typedef vnl_matrix_fixed< double, 3, 3> TransformMatrixType;

  typedef itk::AffineTransform< double >  AffineTransformType;
  typedef itk::Euler3DTransform< double >  RigidTransformType;

  void SetCrossModalityOn()
  {
    m_CrossModalityRegistration = true;
  }

  void SetCrossModalityOff()
  {
    m_CrossModalityRegistration = false;
  }

  void SetCrossModality(bool flag)
  {
    if( flag )
      this->SetCrossModalityOn();
    else
      this->SetCrossModalityOff();
  }

  void SetVerbose(bool flag)
  {
    if( flag )
      this->SetVerboseOn();
    else
      this->SetVerboseOff();
  }

  void SetVerboseOn()
  {
    m_Verbose = true;
  }

  void SetVerboseOff()
  {
    m_Verbose = false;
  }

  void SetTransformToRigid()
  {
    m_UseAffineTransform = false;
  }

  void SetTransformToAffine()
  {
    m_UseAffineTransform = true;
  }

  void SetFixedImage( mitk::Image::Pointer );

  void SetMovingImage( mitk::Image::Pointer );

  void SetFixedImageMask( mitk::Image::Pointer mask);

  void SetInitializeByGeometry(bool flag)
  {
    m_InitializeByGeometry = flag;
  }

  void Update();

  unsigned int GetNumberOfParameters()
  {
    unsigned int retValue = 12;
    if(!m_UseAffineTransform)
      retValue = 6;

    return retValue;
  }

  void GetParameters( double* paramArray)
  {
    if( m_EstimatedParameters == NULL )
    {
      mitkThrow() << "No parameters were estimated yet, call Update() first.";
    }

    unsigned int dim = 12;
    if( !m_UseAffineTransform )
      dim = 6;

    for( unsigned int i=0; i<dim; i++)
    {
      *(paramArray+i) = m_EstimatedParameters[i];
    }
  }

  ParametersType GetLastRegistrationParameters()
  {
    if( m_EstimatedParameters == NULL )
    {
      mitkThrow() << "No parameters were estimated yet, call Update() first.";
    }

    unsigned int dim = 12;
    if( !m_UseAffineTransform )
      dim = 6;

    ParametersType params(dim);

    params.SetData( m_EstimatedParameters );
    return params;
  }

  void SetInitialParameters( ParametersType& params )
  {
    m_InitialParameters = params;
  }

  void SetUseAdvancedInterpolation( bool flag)
  {
    m_UseWindowedSincInterpolator = flag;
  }

  void SetUseNearestNeighborInterpolation( bool flag)
  {
    m_UseNearestNeighborInterpolator = flag;
  }

  void SetUseFixedImageMask( bool flag)
  {
    m_UseMask = flag;
  }

  mitk::Image::Pointer GetResampledMovingImage();

  mitk::Image::Pointer GetResampledMovingImage(mitk::Image::Pointer movingImage, double *transform );

  TransformMatrixType GetLastRotationMatrix();


protected:
  PyramidImageRegistrationMethod();

  ~PyramidImageRegistrationMethod();

  mitk::Image::Pointer m_FixedImage;

  mitk::Image::Pointer m_MovingImage;

  mitk::Image::Pointer m_FixedImageMask;

  bool m_CrossModalityRegistration;

  bool m_UseAffineTransform;

  bool m_UseWindowedSincInterpolator;

  bool m_UseNearestNeighborInterpolator;

  bool m_UseMask;

  double* m_EstimatedParameters;

  ParametersType m_InitialParameters;

  bool m_Verbose;

  bool m_InitializeByGeometry;

template <typename TPixel1, unsigned int VImageDimension1, typename TPixel2, unsigned int VImageDimension2>
  void RegisterTwoImagesV4(itk::Image<TPixel1, VImageDimension1>* itkImage1, itk::Image<TPixel2, VImageDimension2>* itkImage2);

  template< typename TPixel, unsigned int VDimension>
  void ResampleMitkImage( itk::Image<TPixel, VDimension>* itkImage,
                          mitk::Image::Pointer& outputImage );

};

} // end namespace

#endif // MITKPYRAMIDIMAGEREGISTRATION_H