Main class for the rigid registration pipeline. More...

#include <mitkPyramidalRegistrationMethod.h>

Inheritance diagram for mitk::PyramidalRegistrationMethod:

Collaboration diagram for mitk::PyramidalRegistrationMethod:

Public Types
typedef itk::SingleValuedNonLinearOptimizer	OptimizerType
typedef itk::ImageMaskSpatialObject< 3 >	MaskType
typedef PyramidalRegistrationMethod	Self
typedef ImageToImageFilter	Superclass
typedef itk::SmartPointer< Self >	Pointer
typedef itk::SmartPointer < const Self >	ConstPointer
Public Member Functions
virtual const char *	GetClassName () const
void	SetObserver (RigidRegistrationObserver::Pointer observer)
void	SetInterpolator (int interpolator)
virtual void	GenerateData ()
	A version of GenerateData() specific for image processing filters.
virtual void	SetReferenceImage (Image::Pointer fixedImage)
virtual void	SetFixedMask (Image::Pointer fixedMask)
virtual void	SetMovingMask (Image::Pointer movingMask)
void	SetOptimizerParameters (OptimizerParameters::Pointer optimizerParameters)
OptimizerParameters::Pointer	GetOptimizerParameters ()
void	SetTransformParameters (TransformParameters::Pointer transformParameters)
TransformParameters::Pointer	GetTransformParameters ()
void	SetMetricParameters (MetricParameters::Pointer metricParameters)
MetricParameters::Pointer	GetMetricParameters ()
void	SetPresets (std::vector< std::string > presets)
virtual void	SetFixedSchedule (itk::Array2D< unsigned int > _arg)
virtual void	SetMovingSchedule (itk::Array2D< unsigned int > _arg)
virtual void	SetMatchHistograms (bool _arg)
virtual mitk::RigidRegistrationTestPreset *	GetPreset ()
virtual void	SetBlurFixedImage (bool _arg)
virtual void	SetBlurMovingImage (bool _arg)
Static Public Member Functions
static Pointer	New ()
Static Public Attributes
static const int	LINEARINTERPOLATOR = 0
static const int	NEARESTNEIGHBORINTERPOLATOR = 1
Protected Member Functions
	PyramidalRegistrationMethod ()
virtual	~PyramidalRegistrationMethod ()
template<typename TPixel , unsigned int VImageDimension>
void	GenerateData2 (itk::Image< TPixel, VImageDimension > *itkImage1)
void	GenerateOutputInformation ()
Protected Attributes
RigidRegistrationObserver::Pointer	m_Observer
int	m_Interpolator
Image::Pointer	m_ReferenceImage
Image::Pointer	m_FixedMask
Image::Pointer	m_MovingMask

Detailed Description

Main class for the rigid registration pipeline.

Author:: Thomas van Bruggen

Definition at line 51 of file mitkPyramidalRegistrationMethod.h.

Member Typedef Documentation

typedef itk::SmartPointer<const Self> mitk::PyramidalRegistrationMethod::ConstPointer

Definition at line 60 of file mitkPyramidalRegistrationMethod.h.

typedef itk::ImageMaskSpatialObject< 3 > mitk::PyramidalRegistrationMethod::MaskType

Definition at line 57 of file mitkPyramidalRegistrationMethod.h.

typedef itk::SingleValuedNonLinearOptimizer mitk::PyramidalRegistrationMethod::OptimizerType

Definition at line 56 of file mitkPyramidalRegistrationMethod.h.

typedef itk::SmartPointer<Self> mitk::PyramidalRegistrationMethod::Pointer

Definition at line 60 of file mitkPyramidalRegistrationMethod.h.

typedef PyramidalRegistrationMethod mitk::PyramidalRegistrationMethod::Self

Definition at line 60 of file mitkPyramidalRegistrationMethod.h.

typedef ImageToImageFilter mitk::PyramidalRegistrationMethod::Superclass

Definition at line 60 of file mitkPyramidalRegistrationMethod.h.

Constructor & Destructor Documentation

mitk::PyramidalRegistrationMethod::PyramidalRegistrationMethod ( ) [protected]

Definition at line 21 of file mitkPyramidalRegistrationMethod.cpp.

References mitk::Image::New(), mitk::MetricParameters::New(), mitk::TransformParameters::New(), and mitk::OptimizerParameters::New().

               {

  PyramidalRegistrationMethod::PyramidalRegistrationMethod() : m_Observer(NULL), m_Interpolator(0)
  {
    m_OptimizerParameters = OptimizerParameters::New();
    m_TransformParameters = TransformParameters::New();
    m_MetricParameters = MetricParameters::New();
    m_ReferenceImage = Image::New();
    m_MovingMask = Image::New();
    m_FixedMask = Image::New();

    m_Preset = new mitk::RigidRegistrationTestPreset();

    bool succeed = m_Preset->LoadPreset();
    if(!succeed)
    {
       std::cout << "RigidRegistrationParameters.xml is empty or does not exist. There are no presets to select." << std::endl;
       return;
    }
    
    m_UseMask = false;
    m_BlurMovingImage = true;
    m_BlurFixedImage = true;

mitk::PyramidalRegistrationMethod::~PyramidalRegistrationMethod ( ) [protected, virtual]

Definition at line 45 of file mitkPyramidalRegistrationMethod.cpp.

Member Function Documentation

void mitk::PyramidalRegistrationMethod::GenerateData ( ) [virtual]

A version of GenerateData() specific for image processing filters.

This implementation will split the processing across multiple threads. The buffer is allocated by this method. Then the BeforeThreadedGenerateData() method is called (if provided). Then, a series of threads are spawned each calling ThreadedGenerateData(). After all the threads have completed processing, the AfterThreadedGenerateData() method is called (if provided). If an image processing filter cannot be threaded, the filter should provide an implementation of GenerateData(). That implementation is responsible for allocating the output buffer. If a filter an be threaded, it should NOT provide a GenerateData() method but should provide a ThreadedGenerateData() instead.

See also:: ThreadedGenerateData()

Reimplemented from mitk::ImageSource.

Definition at line 50 of file mitkPyramidalRegistrationMethod.cpp.

  {
    if (this->GetInput())
    {
      AccessByItk(this->GetInput(), GenerateData2);

template<typename TPixel , unsigned int VImageDimension>

void mitk::PyramidalRegistrationMethod::GenerateData2 ( itk::Image< TPixel, VImageDimension > * itkImage1 ) [protected]

Definition at line 46 of file mitkPyramidalRegistrationMethod.txx.

References mitk::CastToItkImage(), mitk::RigidRegistrationTestPreset::getMetricValues(), mitk::RigidRegistrationTestPreset::getOptimizerValues(), mitk::RigidRegistrationTestPreset::getTransformValues(), m_Observer, m_ReferenceImage, and New().

               {

 
  template<typename TPixel, unsigned int VImageDimension>
  void PyramidalRegistrationMethod::GenerateData2(itk::Image<TPixel, VImageDimension>* itkImage1)
  {    

    // TYPEDEFS        
    typedef itk::Image< TPixel, VImageDimension >             ImageType;
                    
                typedef float                                             InternalPixelType;
                typedef itk::Image< InternalPixelType, VImageDimension >  InternalImageType;

    typedef typename itk::Transform
      < double, VImageDimension, VImageDimension >            TransformType;
    typedef mitk::TransformFactory<InternalPixelType, 
                                   VImageDimension>           TransformFactoryType;
    typedef itk::LinearInterpolateImageFunction
      < InternalImageType, double >                           InterpolatorType;
    typedef mitk::MetricFactory
      <InternalPixelType, VImageDimension>                    MetricFactoryType;
    typedef itk::RecursiveMultiResolutionPyramidImageFilter<
                                                                                                                                                        InternalImageType,
                                                                                                                                                        InternalImageType >         ImagePyramidType;
    typedef itk::DiscreteGaussianImageFilter
      <ImageType, InternalImageType>                          GaussianFilterType;    
   


    typedef itk::MultiResolutionImageRegistrationMethod< 
                                                                                                                                                        InternalImageType, 
                                                                                                                                                        InternalImageType >     RegistrationType;       
    typedef RegistrationInterfaceCommand
      <RegistrationType, TPixel>                              CommandType;

    typedef itk::CastImageFilter<ImageType, 
                                  InternalImageType>          CastImageFilterType;

    itk::Array<double> initialParameters;
    if(m_TransformParameters->GetInitialParameters().size())
    {
      initialParameters = m_TransformParameters->GetInitialParameters();
    }
   
    // LOAD PARAMETERS
    itk::Array<double> transformValues = m_Preset->getTransformValues(m_Presets[0]);
    itk::Array<double> metricValues = m_Preset->getMetricValues(m_Presets[0]);
    itk::Array<double> optimizerValues = m_Preset->getOptimizerValues(m_Presets[0]);
    m_TransformParameters = ParseTransformParameters(transformValues);
    m_MetricParameters = ParseMetricParameters(metricValues);
    m_OptimizerParameters = ParseOptimizerParameters(optimizerValues);                  


    // The fixed and the moving image
                typename InternalImageType::Pointer fixedImage = InternalImageType::New();
    typename InternalImageType::Pointer movingImage = InternalImageType::New();

  


                mitk::CastToItkImage(m_ReferenceImage, fixedImage); 

     // Blur the moving image        
    if(m_BlurMovingImage)
    {
      typename GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New();
      gaussianFilter->SetInput(itkImage1);
      gaussianFilter->SetVariance(6.0);
      gaussianFilter->SetMaximumError( 0.1 );
      //gaussianFilter->SetMaximumKernelWidth ( 3 );
      gaussianFilter->Update();
      movingImage = gaussianFilter->GetOutput();
    } else{
      typename CastImageFilterType::Pointer castImageFilter = CastImageFilterType::New();
      castImageFilter->SetInput(itkImage1);
      castImageFilter->Update();
      movingImage = castImageFilter->GetOutput();
    }
    
    if(m_MatchHistograms)
    {
      typedef itk::RescaleIntensityImageFilter<InternalImageType,InternalImageType> FilterType;   
      typedef itk::HistogramMatchingImageFilter<InternalImageType,InternalImageType> HEFilterType;

      typename FilterType::Pointer inputRescaleFilter = FilterType::New();  
      typename FilterType::Pointer referenceRescaleFilter = FilterType::New();  

      referenceRescaleFilter->SetInput(fixedImage);
      inputRescaleFilter->SetInput(movingImage);

      const float desiredMinimum =  0.0;
      const float desiredMaximum =  255.0;
      
      referenceRescaleFilter->SetOutputMinimum( desiredMinimum );
      referenceRescaleFilter->SetOutputMaximum( desiredMaximum );
      referenceRescaleFilter->UpdateLargestPossibleRegion();  
      inputRescaleFilter->SetOutputMinimum( desiredMinimum );
      inputRescaleFilter->SetOutputMaximum( desiredMaximum );
      inputRescaleFilter->UpdateLargestPossibleRegion();

      // Histogram match the images
      typename HEFilterType::Pointer intensityEqualizeFilter = HEFilterType::New();

      intensityEqualizeFilter->SetReferenceImage( inputRescaleFilter->GetOutput() );
      intensityEqualizeFilter->SetInput( referenceRescaleFilter->GetOutput() );
      intensityEqualizeFilter->SetNumberOfHistogramLevels( 64 );
      intensityEqualizeFilter->SetNumberOfMatchPoints( 12 );
      intensityEqualizeFilter->ThresholdAtMeanIntensityOn();
      intensityEqualizeFilter->Update();

      //fixedImage = referenceRescaleFilter->GetOutput();
      //movingImage = IntensityEqualizeFilter->GetOutput();

      fixedImage = intensityEqualizeFilter->GetOutput();
      movingImage = inputRescaleFilter->GetOutput();
     
    }
  
    
    
    typename TransformFactoryType::Pointer transFac = TransformFactoryType::New();
    transFac->SetTransformParameters(m_TransformParameters);
    transFac->SetFixedImage(fixedImage);
    transFac->SetMovingImage(movingImage);
    typename TransformType::Pointer transform = transFac->GetTransform();
    
                
    typename InterpolatorType::Pointer   interpolator  = InterpolatorType::New();         
    typename MetricFactoryType::Pointer metFac = MetricFactoryType::New();
    metFac->SetMetricParameters(m_MetricParameters);

    
    typename OptimizerFactory::Pointer optFac = OptimizerFactory::New();
    optFac->SetOptimizerParameters(m_OptimizerParameters);
    optFac->SetNumberOfTransformParameters(transform->GetNumberOfParameters());
    typename OptimizerType::Pointer optimizer = optFac->GetOptimizer(); 

    // optimizer scales
    if (m_TransformParameters->GetUseOptimizerScales())
    {
      itk::Array<double> optimizerScales = m_TransformParameters->GetScales();
      typename OptimizerType::ScalesType scales( transform->GetNumberOfParameters() );
      for (unsigned int i = 0; i < scales.Size(); i++)
      {
        scales[i] = optimizerScales[i];
      }
      optimizer->SetScales( scales );
    }
        
                typename ImagePyramidType::Pointer fixedImagePyramid =  ImagePyramidType::New();
                typename ImagePyramidType::Pointer movingImagePyramid = ImagePyramidType::New();  
    
    if(m_FixedSchedule.size() > 0 && m_MovingSchedule.size() > 0)
    {
      fixedImagePyramid->SetSchedule(m_FixedSchedule);
      movingImagePyramid->SetSchedule(m_MovingSchedule);
      // Otherwise just use the default schedule
    }


    

                typename RegistrationType::Pointer registration = RegistrationType::New();
                registration->SetOptimizer(           optimizer     );
                registration->SetTransform(           transform     );
                registration->SetInterpolator(        interpolator  );
    registration->SetMetric(              metFac->GetMetric()  );        
    registration->SetFixedImagePyramid(   fixedImagePyramid );
                registration->SetMovingImagePyramid(  movingImagePyramid );
          registration->SetFixedImage(          fixedImage );     
                registration->SetMovingImage(         movingImage );    
                registration->SetFixedImageRegion(    fixedImage->GetBufferedRegion() );     
    
    if(transFac->GetTransformParameters()->GetInitialParameters().size())
    {
      registration->SetInitialTransformParameters( transFac->GetTransformParameters()->GetInitialParameters() );
    }
    else
    {
      itk::Array<double> zeroInitial;
      zeroInitial.set_size(transform->GetNumberOfParameters());
      zeroInitial.fill(0.0);
      zeroInitial[0] = 1.0;
      zeroInitial[4] = 1.0;
      zeroInitial[8] = 1.0;
      registration->SetInitialTransformParameters( zeroInitial );
    }

   
    if(m_UseMask)
    {
      itk::ImageMaskSpatialObject< VImageDimension>* mask = 
        dynamic_cast< itk::ImageMaskSpatialObject< VImageDimension>* > ( m_BrainMask.GetPointer() );
      registration->GetMetric()->SetFixedImageMask(mask);
    }
    
    // registering command observer with the optimizer        
                if (m_Observer.IsNotNull())
                {
                  m_Observer->AddStepsToDo(20);
                  optimizer->AddObserver(itk::AnyEvent(), m_Observer);
                  registration->AddObserver(itk::AnyEvent(), m_Observer);
                  transform->AddObserver(itk::AnyEvent(), m_Observer);
                }                       

    typename CommandType::Pointer command = CommandType::New();
    command->observer = m_Observer;
    command->m_Presets = m_Presets;
    command->m_UseMask = m_UseMask;
    command->m_BrainMask = m_BrainMask;

                registration->AddObserver( itk::IterationEvent(), command );        
    registration->SetSchedules(m_FixedSchedule, m_MovingSchedule);        
    

    // Start the registration process
                try 
                { 
                  registration->StartRegistration(); 
                } 
                catch( itk::ExceptionObject & err ) 
                { 
                  std::cout << "ExceptionObject caught !" << std::endl; 
                  std::cout << err << std::endl;                                
                }
    if (m_Observer.IsNotNull())
    {
      optimizer->RemoveAllObservers();
      registration->RemoveAllObservers();
      transform->RemoveAllObservers();

void mitk::PyramidalRegistrationMethod::GenerateOutputInformation ( void ) [inline, protected]

Definition at line 135 of file mitkPyramidalRegistrationMethod.h.

{};

virtual const char* mitk::PyramidalRegistrationMethod::GetClassName ( ) const [virtual]

MetricParameters::Pointer mitk::PyramidalRegistrationMethod::GetMetricParameters ( ) [inline]

Definition at line 104 of file mitkPyramidalRegistrationMethod.h.

    {
      return m_MetricParameters;
    }

OptimizerParameters::Pointer mitk::PyramidalRegistrationMethod::GetOptimizerParameters ( ) [inline]

Definition at line 84 of file mitkPyramidalRegistrationMethod.h.

    {
      return m_OptimizerParameters;
    }

virtual mitk::RigidRegistrationTestPreset* mitk::PyramidalRegistrationMethod::GetPreset ( ) [virtual]

TransformParameters::Pointer mitk::PyramidalRegistrationMethod::GetTransformParameters ( ) [inline]

Definition at line 94 of file mitkPyramidalRegistrationMethod.h.

    {
      return m_TransformParameters;
    }

static Pointer mitk::PyramidalRegistrationMethod::New ( ) [static]

Method for creation through the object factory.

Reimplemented from mitk::ImageToImageFilter.

Referenced by GenerateData2().

virtual void mitk::PyramidalRegistrationMethod::SetBlurFixedImage ( bool _arg ) [virtual]

virtual void mitk::PyramidalRegistrationMethod::SetBlurMovingImage ( bool _arg ) [virtual]

void mitk::PyramidalRegistrationMethod::SetFixedMask ( Image::Pointer fixedMask ) [virtual]

Definition at line 170 of file mitkPyramidalRegistrationMethod.cpp.

  {
    m_FixedMask = FixedMask;
    SetNthInput(4, m_FixedMask);

virtual void mitk::PyramidalRegistrationMethod::SetFixedSchedule ( itk::Array2D< unsigned int > _arg ) [virtual]

void mitk::PyramidalRegistrationMethod::SetInterpolator ( int interpolator )

Definition at line 63 of file mitkPyramidalRegistrationMethod.cpp.

virtual void mitk::PyramidalRegistrationMethod::SetMatchHistograms ( bool _arg ) [virtual]

void mitk::PyramidalRegistrationMethod::SetMetricParameters ( MetricParameters::Pointer metricParameters ) [inline]

Definition at line 99 of file mitkPyramidalRegistrationMethod.h.

    {
      m_MetricParameters = metricParameters;
    }

void mitk::PyramidalRegistrationMethod::SetMovingMask ( Image::Pointer movingMask ) [virtual]

Definition at line 163 of file mitkPyramidalRegistrationMethod.cpp.

  {
    m_MovingMask = movingMask;
    SetNthInput(3, m_MovingMask);

virtual void mitk::PyramidalRegistrationMethod::SetMovingSchedule ( itk::Array2D< unsigned int > _arg ) [virtual]

void mitk::PyramidalRegistrationMethod::SetObserver ( RigidRegistrationObserver::Pointer observer )

Definition at line 58 of file mitkPyramidalRegistrationMethod.cpp.

void mitk::PyramidalRegistrationMethod::SetOptimizerParameters ( OptimizerParameters::Pointer optimizerParameters ) [inline]

Definition at line 79 of file mitkPyramidalRegistrationMethod.h.

    {
      m_OptimizerParameters = optimizerParameters;
    }

void mitk::PyramidalRegistrationMethod::SetPresets ( std::vector< std::string > presets ) [inline]

Definition at line 109 of file mitkPyramidalRegistrationMethod.h.

    {
      m_Presets = presets;
    }

void mitk::PyramidalRegistrationMethod::SetReferenceImage ( Image::Pointer fixedImage ) [virtual]

Definition at line 68 of file mitkPyramidalRegistrationMethod.cpp.

  {
    m_ReferenceImage = fixedImage;
    SetNthInput(1, m_ReferenceImage);

void mitk::PyramidalRegistrationMethod::SetTransformParameters ( TransformParameters::Pointer transformParameters ) [inline]

Definition at line 89 of file mitkPyramidalRegistrationMethod.h.

    {
      m_TransformParameters = transformParameters;      
    }

Member Data Documentation

const int mitk::PyramidalRegistrationMethod::LINEARINTERPOLATOR = 0 [static]

Definition at line 64 of file mitkPyramidalRegistrationMethod.h.

Image::Pointer mitk::PyramidalRegistrationMethod::m_FixedMask [protected]

Definition at line 132 of file mitkPyramidalRegistrationMethod.h.

int mitk::PyramidalRegistrationMethod::m_Interpolator [protected]

Definition at line 130 of file mitkPyramidalRegistrationMethod.h.

Image::Pointer mitk::PyramidalRegistrationMethod::m_MovingMask [protected]

Definition at line 133 of file mitkPyramidalRegistrationMethod.h.

RigidRegistrationObserver::Pointer mitk::PyramidalRegistrationMethod::m_Observer [protected]

Definition at line 129 of file mitkPyramidalRegistrationMethod.h.

Referenced by GenerateData2().

Image::Pointer mitk::PyramidalRegistrationMethod::m_ReferenceImage [protected]

Definition at line 131 of file mitkPyramidalRegistrationMethod.h.

Referenced by GenerateData2().

const int mitk::PyramidalRegistrationMethod::NEARESTNEIGHBORINTERPOLATOR = 1 [static]

Definition at line 65 of file mitkPyramidalRegistrationMethod.h.

The documentation for this class was generated from the following files:

mitk::PyramidalRegistrationMethod Class Reference [Classes related to rigid registration]

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

mitk::PyramidalRegistrationMethod Class Reference
[Classes related to rigid registration]