Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Protected Member Functions

mitk::RegistrationInterfaceCommand< TRegistration, TPixel > Class Template Reference

#include <mitkRegistrationInterfaceCommand.h>

List of all members.

Public Types

typedef
RegistrationInterfaceCommand 
Self
typedef itk::Command Superclass
typedef itk::SmartPointer< SelfPointer
typedef
itk::MultiResolutionImageRegistrationMethod
< itk::Image< float, 3 >
, itk::Image< float, 3 > > 
RegistrationType
typedef RegistrationTypeRegistrationPointer
typedef
itk::SingleValuedNonLinearOptimizer 
OptimizerType
typedef OptimizerTypeOptimizerPointer
typedef
itk::ImageMaskSpatialObject< 3 > 
MaskType

Public Member Functions

void Execute (itk::Object *object, const itk::EventObject &event)
void Execute (const itk::Object *, const itk::EventObject &)

Static Public Member Functions

static Pointer New ()

Public Attributes

mitk::RigidRegistrationObserver::Pointer observer
bool m_UseMask
std::vector< std::string > m_Presets
MaskType::Pointer m_BrainMask

Protected Member Functions

 RegistrationInterfaceCommand ()

Detailed Description

template<class TRegistration, class TPixel>
class mitk::RegistrationInterfaceCommand< TRegistration, TPixel >

Definition at line 21 of file mitkRegistrationInterfaceCommand.h.


Member Typedef Documentation

template<class TRegistration , class TPixel >
typedef itk::ImageMaskSpatialObject< 3 > mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::MaskType

Definition at line 46 of file mitkRegistrationInterfaceCommand.h.

template<class TRegistration , class TPixel >
typedef OptimizerType* mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::OptimizerPointer

Definition at line 45 of file mitkRegistrationInterfaceCommand.h.

template<class TRegistration , class TPixel >
typedef itk::SingleValuedNonLinearOptimizer mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::OptimizerType

Definition at line 44 of file mitkRegistrationInterfaceCommand.h.

template<class TRegistration , class TPixel >
typedef itk::SmartPointer<Self> mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::Pointer

Definition at line 27 of file mitkRegistrationInterfaceCommand.h.

template<class TRegistration , class TPixel >
typedef RegistrationType* mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::RegistrationPointer

Definition at line 43 of file mitkRegistrationInterfaceCommand.h.

template<class TRegistration , class TPixel >
typedef itk::MultiResolutionImageRegistrationMethod< itk::Image<float, 3> , itk::Image<float, 3> > mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::RegistrationType

Definition at line 40 of file mitkRegistrationInterfaceCommand.h.

template<class TRegistration , class TPixel >
typedef RegistrationInterfaceCommand mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::Self

Definition at line 25 of file mitkRegistrationInterfaceCommand.h.

template<class TRegistration , class TPixel >
typedef itk::Command mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::Superclass

Definition at line 26 of file mitkRegistrationInterfaceCommand.h.


Constructor & Destructor Documentation

template<class TRegistration , class TPixel >
mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::RegistrationInterfaceCommand (  ) [inline, protected]

Member Function Documentation

template<class TRegistration , class TPixel >
void mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::Execute ( itk::Object *  object,
const itk::EventObject &  event 
) [inline]

Definition at line 54 of file mitkRegistrationInterfaceCommand.h.

References mitk::TransformParameters::AFFINETRANSFORM, mitk::RigidRegistrationTestPreset::getOptimizerValues(), mitk::RigidRegistrationTestPreset::getTransformValues(), mitk::OptimizerParameters::GRADIENTDESCENTOPTIMIZER, mitk::RigidRegistrationTestPreset::LoadPreset(), mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::m_Presets, mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::New(), mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::observer, and mitk::OptimizerParameters::REGULARSTEPGRADIENTDESCENTOPTIMIZER.

                {
          if( !(itk::IterationEvent().CheckEvent( &event )) )
                        {
                          return;
                        }
        
      RegistrationPointer registration = dynamic_cast<RegistrationPointer>( object );
        
      
      /*OptimizerPointer optimizer = dynamic_cast< OptimizerPointer >( 
                                                                                                     registration->GetOptimizer() );*/

      
      std::cout << "-------------------------------------" << std::endl;
      std::cout << "MultiResolution Level : "
                << registration->GetCurrentLevel()  << std::endl << std::endl;
      

      if ( registration->GetCurrentLevel() == 0 )
      {
        // Nothing needs to be changed in the first step
      }
      else
      {
        // Load presets and make a new optimizer if that succeeds
        mitk::RigidRegistrationTestPreset *preset = new mitk::RigidRegistrationTestPreset();

        if( preset->LoadPreset() )
        {          
        
          mitk::OptimizerParameters::Pointer optimizerParameters = mitk::OptimizerParameters::New();
          itk::Array<double> optimizerValues = preset->getOptimizerValues(m_Presets[ registration->GetCurrentLevel() ]);

          optimizerParameters->SetOptimizer(optimizerValues[0]);
          optimizerParameters->SetMaximize(optimizerValues[1]); //should be when used with maximize mutual information for example

          if(optimizerValues[0] == mitk::OptimizerParameters::GRADIENTDESCENTOPTIMIZER)
          {        
            optimizerParameters->SetLearningRateGradientDescent(optimizerValues[2]);
            optimizerParameters->SetNumberOfIterationsGradientDescent(optimizerValues[3]);
          }

          if(optimizerValues[0] == mitk::OptimizerParameters::REGULARSTEPGRADIENTDESCENTOPTIMIZER)
          {
           cout << "use regularstepgradientdescent" << endl;
           optimizerParameters->SetGradientMagnitudeToleranceRegularStepGradientDescent(optimizerValues[2]);
           optimizerParameters->SetMinimumStepLengthRegularStepGradientDescent(optimizerValues[3]);
           optimizerParameters->SetMaximumStepLengthRegularStepGradientDescent(optimizerValues[4]);
           optimizerParameters->SetRelaxationFactorRegularStepGradientDescent(optimizerValues[5]);
           optimizerParameters->SetNumberOfIterationsRegularStepGradientDescent(optimizerValues[6]);       
          }

          
          // Typedef for the OptimizerFactory and initialisation of the optimizer using m_OptimizerParameters
          typename OptimizerFactory::Pointer optFac = OptimizerFactory::New();
          optFac->SetOptimizerParameters(optimizerParameters);
          optFac->SetNumberOfTransformParameters(registration->GetTransform()->GetNumberOfParameters());
          typename OptimizerType::Pointer optimizer = optFac->GetOptimizer();

          if(observer.IsNotNull())
          {
            optimizer->AddObserver(itk::AnyEvent(), observer);
          }

         
          itk::Array<double> transformValues = preset->getTransformValues(m_Presets[ registration->GetCurrentLevel() ]);
          
          itk::Array<double> scales;
          if(transformValues[0] == mitk::TransformParameters::AFFINETRANSFORM) scales.SetSize(12);
          mitk::TransformParameters::Pointer transformParameters = mitk::TransformParameters::New();
          transformParameters->SetTransform(transformValues[0]);          

          for(unsigned int i = 0; i < scales.size(); i++)
          {
            scales[i] = transformValues[i+2];
            std::cout << "scale " << i << ": " << scales[i] << std::endl;
          }

          transformParameters->SetScales(scales);      
          //transformParameters->SetTransformInitializerOn(false);         
         
          
          // Use Scales      
          if(transformValues[1] == 1)
          {
            transformParameters->SetUseOptimizerScales(true);              
          } 

          if (transformParameters->GetUseOptimizerScales())
          {
            itk::Array<double> optimizerScales = transformParameters->GetScales();
            typename OptimizerType::ScalesType scales( registration->GetTransform()->GetNumberOfParameters() );
            for (unsigned int i = 0; i < scales.Size(); i++)
            {
              scales[i] = optimizerScales[i];
            }
            optimizer->SetScales( scales );           
          }
          
          
          registration->SetOptimizer(optimizer);
      

        }      

       
      }
         
      registration->Print(std::cout,0);
      std::cout << std::endl;
      std::cout << "METRIC" << std::endl;
      registration->GetMetric()->Print(std::cout,0);
      std::cout << std::endl;
      std::cout << "OPTIMIZER" << std::endl;
      registration->GetOptimizer()->Print(std::cout,0);
      std::cout << std::endl;
      std::cout << "TRANSFORM" << std::endl;
      registration->GetTransform()->Print(std::cout,0);
    }
template<class TRegistration , class TPixel >
void mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::Execute ( const itk::Object *  ,
const itk::EventObject &   
) [inline]

Definition at line 175 of file mitkRegistrationInterfaceCommand.h.

      { return; }
template<class TRegistration , class TPixel >
static Pointer mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::New (  ) [static]

Member Data Documentation

template<class TRegistration , class TPixel >
MaskType::Pointer mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::m_BrainMask

Definition at line 52 of file mitkRegistrationInterfaceCommand.h.

template<class TRegistration , class TPixel >
std::vector<std::string> mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::m_Presets
template<class TRegistration , class TPixel >
bool mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::m_UseMask
template<class TRegistration , class TPixel >
mitk::RigidRegistrationObserver::Pointer mitk::RegistrationInterfaceCommand< TRegistration, TPixel >::observer

The documentation for this class was generated from the following file:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines