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

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

This class creates an optimizer for a rigid registration process. More...

#include <mitkOptimizerFactory.h>

List of all members.

Public Types

typedef OptimizerFactory Self
typedef Object Superclass
typedef itk::SmartPointer< Self > Pointer
typedef itk::SmartPointer
< const Self > 		ConstPointer
typedef
itk::SingleValuedNonLinearOptimizer 		OptimizerType

Public Member Functions

virtual const char * GetClassName () const
OptimizerType::Pointer GetOptimizer ()
 Returns the optimizer which then can be used in combination with a transform, a metric and an interpolator within a registration pipeline.
void SetNumberOfTransformParameters (int numberTransformParameters)
 Sets the number of transformParameters.
void SetOptimizerParameters (OptimizerParameters::Pointer optimizerParameters)
 Sets the instance to the optimizer parameters class which holds all parameters for the new optimizer.
OptimizerParameters::Pointer GetOptimizerParameters ()
 Returns the instance to the optimizer parameters class which holds all parameters for the new optimizer.

Static Public Member Functions

static Pointer New ()

Protected Member Functions

 OptimizerFactory ()
 ~OptimizerFactory ()

Detailed Description

This class creates an optimizer for a rigid registration process.

This class will e.g. be instantiated by mitkImageRegistrationMethod and an optimizer corresponding to the integer value stored in mitkOptimizerParameters will be created. Therefore SetOptimizerParameters() has to be called with an instance of mitkOptimizerParameters, which holds all parameter informations for the new optimizer.

GetOptimizer() returns the optimizer which then can be used in combination with a transform, a metric and an interpolator within a registration pipeline.

Author:
Daniel Stein

Definition at line 45 of file mitkOptimizerFactory.h.

Member Typedef Documentation

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

Definition at line 49 of file mitkOptimizerFactory.h.

typedef itk::SingleValuedNonLinearOptimizer mitk::OptimizerFactory::OptimizerType

Definition at line 50 of file mitkOptimizerFactory.h.

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

Definition at line 49 of file mitkOptimizerFactory.h.

typedef OptimizerFactory mitk::OptimizerFactory::Self

Definition at line 49 of file mitkOptimizerFactory.h.

typedef Object mitk::OptimizerFactory::Superclass

Definition at line 49 of file mitkOptimizerFactory.h.

Constructor & Destructor Documentation

mitk::OptimizerFactory::OptimizerFactory (  ) [protected]

Definition at line 21 of file mitkOptimizerFactory.cpp.

Referenced by GetOptimizer().

               {
mitk::OptimizerFactory::~OptimizerFactory (  ) [protected]

Definition at line 25 of file mitkOptimizerFactory.cpp.

Referenced by GetOptimizer().

               {

Member Function Documentation

virtual const char* mitk::OptimizerFactory::GetClassName (  ) const [virtual]
OptimizerFactory::OptimizerType::Pointer mitk::OptimizerFactory::GetOptimizer (  )

Returns the optimizer which then can be used in combination with a transform, a metric and an interpolator within a registration pipeline.

Definition at line 34 of file mitkOptimizerFactory.cpp.

References mitk::OptimizerParameters::AMOEBAOPTIMIZER, mitk::OptimizerParameters::CONJUGATEGRADIENTOPTIMIZER, mitk::OptimizerParameters::EXHAUSTIVEOPTIMIZER, mitk::OptimizerParameters::FRPROPTIMIZER, mitk::OptimizerParameters::GRADIENTDESCENTOPTIMIZER, mitk::OptimizerParameters::LBFGSBOPTIMIZER, mitk::OptimizerParameters::LBFGSOPTIMIZER, MITK_ERROR, New(), mitk::OptimizerParameters::ONEPLUSONEEVOLUTIONARYOPTIMIZER, OptimizerFactory(), mitk::OptimizerParameters::POWELLOPTIMIZER, mitk::OptimizerParameters::QUATERNIONRIGIDTRANSFORMGRADIENTDESCENTOPTIMIZER, mitk::OptimizerParameters::REGULARSTEPGRADIENTDESCENTOPTIMIZER, SetNumberOfTransformParameters(), mitk::OptimizerParameters::SPSAOPTIMIZER, mitk::OptimizerParameters::VERSORRIGID3DTRANSFORMOPTIMIZER, mitk::OptimizerParameters::VERSORTRANSFORMOPTIMIZER, and ~OptimizerFactory().

               {

  OptimizerFactory::OptimizerFactory() : m_OptimizerParameters(NULL), m_NumberTransformParameters(16)
  {
  }

  OptimizerFactory::~OptimizerFactory()
  {
  }

  void OptimizerFactory::SetNumberOfTransformParameters(int numberTransformParameters)
  {
    m_NumberTransformParameters = numberTransformParameters;
  }

  OptimizerFactory::OptimizerType::Pointer OptimizerFactory::GetOptimizer( )
  {
    if( m_OptimizerParameters.IsNull() ) 
    {
      MITK_ERROR << "No parameters set! Returning\n";
      return NULL;
    }
    int optimizer = m_OptimizerParameters->GetOptimizer();
    if (optimizer == OptimizerParameters::EXHAUSTIVEOPTIMIZER)
    {
      itk::ExhaustiveOptimizer::Pointer OptimizerPointer = itk::ExhaustiveOptimizer::New();
      OptimizerPointer->SetStepLength( m_OptimizerParameters->GetStepLengthExhaustive() );
      itk::ExhaustiveOptimizer::StepsType steps( m_NumberTransformParameters );
      for (int i = 0; i < m_NumberTransformParameters; i++)
      {
        steps[i] = m_OptimizerParameters->GetNumberOfStepsExhaustive();
      }
      
      OptimizerPointer->SetNumberOfSteps( steps );

      return OptimizerPointer.GetPointer();
    }
    else if (optimizer == OptimizerParameters::GRADIENTDESCENTOPTIMIZER)
    {
      itk::GradientDescentOptimizer::Pointer OptimizerPointer = itk::GradientDescentOptimizer::New();
      OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize());
      OptimizerPointer->SetLearningRate(m_OptimizerParameters->GetLearningRateGradientDescent());
      OptimizerPointer->SetNumberOfIterations( m_OptimizerParameters->GetNumberOfIterationsGradientDescent() );
      return OptimizerPointer.GetPointer();
    }
    else if (optimizer == OptimizerParameters::QUATERNIONRIGIDTRANSFORMGRADIENTDESCENTOPTIMIZER)
    {
      itk::QuaternionRigidTransformGradientDescentOptimizer::Pointer OptimizerPointer = itk::QuaternionRigidTransformGradientDescentOptimizer::New();
      OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize());  
      OptimizerPointer->SetLearningRate(m_OptimizerParameters->GetLearningRateQuaternionRigidTransformGradientDescent());
      OptimizerPointer->SetNumberOfIterations( m_OptimizerParameters->GetNumberOfIterationsQuaternionRigidTransformGradientDescent() );
      return OptimizerPointer.GetPointer();
    }
    else if (optimizer == OptimizerParameters::LBFGSBOPTIMIZER)
    {
      itk::LBFGSBOptimizer::Pointer OptimizerPointer = itk::LBFGSBOptimizer::New();
      // Set up boundary conditions
      itk::LBFGSBOptimizer::BoundValueType lower(12);
      itk::LBFGSBOptimizer::BoundValueType upper(12);
      itk::LBFGSBOptimizer::BoundSelectionType select(12);

      lower.Fill( -1 );
      upper.Fill( 10 );
      select.Fill( 2 );

      OptimizerPointer->SetLowerBound( lower );
      OptimizerPointer->SetUpperBound( upper );
      OptimizerPointer->SetBoundSelection( select );
      OptimizerPointer->SetCostFunctionConvergenceFactor(1e+1);
      OptimizerPointer->SetMaximumNumberOfCorrections(5);
      OptimizerPointer->SetProjectedGradientTolerance(1e-5);
      OptimizerPointer->SetMaximumNumberOfEvaluations(500);
      OptimizerPointer->SetMaximumNumberOfIterations( 200 );
      return OptimizerPointer.GetPointer();
    }
    else if (optimizer == OptimizerParameters::ONEPLUSONEEVOLUTIONARYOPTIMIZER)
    {
      itk::OnePlusOneEvolutionaryOptimizer::Pointer OptimizerPointer = itk::OnePlusOneEvolutionaryOptimizer::New();
      OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
      itk::Statistics::NormalVariateGenerator::Pointer generator = itk::Statistics::NormalVariateGenerator::New();
      generator->Initialize(12345);
      OptimizerPointer->SetNormalVariateGenerator(generator);
      OptimizerPointer->SetGrowthFactor(m_OptimizerParameters->GetGrowthFactorOnePlusOneEvolutionary());
      OptimizerPointer->SetShrinkFactor(m_OptimizerParameters->GetShrinkFactorOnePlusOneEvolutionary());
      OptimizerPointer->SetEpsilon(m_OptimizerParameters->GetEpsilonOnePlusOneEvolutionary());
      OptimizerPointer->SetInitialRadius(m_OptimizerParameters->GetInitialRadiusOnePlusOneEvolutionary());
      OptimizerPointer->SetMaximumIteration(m_OptimizerParameters->GetNumberOfIterationsOnePlusOneEvolutionary());
      return OptimizerPointer.GetPointer();
    }
    else if (optimizer == OptimizerParameters::POWELLOPTIMIZER)
    {
      itk::PowellOptimizer::Pointer OptimizerPointer = itk::PowellOptimizer::New();
      OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
      OptimizerPointer->SetStepLength( m_OptimizerParameters->GetStepLengthPowell() );
      OptimizerPointer->SetStepTolerance( m_OptimizerParameters->GetStepTolerancePowell() );
      OptimizerPointer->SetValueTolerance( m_OptimizerParameters->GetValueTolerancePowell() );
      OptimizerPointer->SetMaximumIteration( m_OptimizerParameters->GetNumberOfIterationsPowell() );
      return OptimizerPointer.GetPointer();
    }
    else if (optimizer == OptimizerParameters::FRPROPTIMIZER)
    {
      itk::FRPROptimizer::Pointer OptimizerPointer = itk::FRPROptimizer::New();
      OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
      OptimizerPointer->SetStepLength(m_OptimizerParameters->GetStepLengthFRPR());
      if (m_OptimizerParameters->GetFletchReevesFRPR())
      {
        OptimizerPointer->SetToFletchReeves();
      }
      else if (m_OptimizerParameters->GetPolakRibiereFRPR())
      {
        OptimizerPointer->SetToPolakRibiere();
      }
      OptimizerPointer->SetMaximumIteration( m_OptimizerParameters->GetNumberOfIterationsFRPR() );
      return OptimizerPointer.GetPointer();
    }
    else if (optimizer == OptimizerParameters::REGULARSTEPGRADIENTDESCENTOPTIMIZER)
    {
      itk::RegularStepGradientDescentOptimizer::Pointer OptimizerPointer = itk::RegularStepGradientDescentOptimizer::New();
      OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
      OptimizerPointer->SetGradientMagnitudeTolerance( m_OptimizerParameters->GetGradientMagnitudeToleranceRegularStepGradientDescent() );
      OptimizerPointer->SetMinimumStepLength( m_OptimizerParameters->GetMinimumStepLengthRegularStepGradientDescent() );
      OptimizerPointer->SetMaximumStepLength( m_OptimizerParameters->GetMaximumStepLengthRegularStepGradientDescent() );
      OptimizerPointer->SetNumberOfIterations( m_OptimizerParameters->GetNumberOfIterationsRegularStepGradientDescent() );
      OptimizerPointer->SetRelaxationFactor( m_OptimizerParameters->GetRelaxationFactorRegularStepGradientDescent() );
      return OptimizerPointer.GetPointer();
    }
    else if (optimizer == OptimizerParameters::VERSORRIGID3DTRANSFORMOPTIMIZER)
    {
      itk::VersorRigid3DTransformOptimizer::Pointer OptimizerPointer = itk::VersorRigid3DTransformOptimizer::New();
      OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
      OptimizerPointer->SetGradientMagnitudeTolerance( m_OptimizerParameters->GetGradientMagnitudeToleranceVersorRigid3DTransform() );
      OptimizerPointer->SetMinimumStepLength( m_OptimizerParameters->GetMinimumStepLengthVersorRigid3DTransform() );
      OptimizerPointer->SetMaximumStepLength( m_OptimizerParameters->GetMaximumStepLengthVersorRigid3DTransform() );
      OptimizerPointer->SetNumberOfIterations( m_OptimizerParameters->GetNumberOfIterationsVersorRigid3DTransform() );
      return OptimizerPointer.GetPointer();
    }
    else if (optimizer == OptimizerParameters::VERSORTRANSFORMOPTIMIZER)
    {
      itk::VersorTransformOptimizer::Pointer OptimizerPointer = itk::VersorTransformOptimizer::New();
      OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
      OptimizerPointer->SetGradientMagnitudeTolerance( m_OptimizerParameters->GetGradientMagnitudeToleranceVersorTransform() );
      OptimizerPointer->SetMinimumStepLength( m_OptimizerParameters->GetMinimumStepLengthVersorTransform() );
      OptimizerPointer->SetMaximumStepLength( m_OptimizerParameters->GetMaximumStepLengthVersorTransform() );
      OptimizerPointer->SetNumberOfIterations( m_OptimizerParameters->GetNumberOfIterationsVersorTransform() );
      return OptimizerPointer.GetPointer();
    }
    else if (optimizer == OptimizerParameters::AMOEBAOPTIMIZER)
    {
      itk::AmoebaOptimizer::Pointer OptimizerPointer = itk::AmoebaOptimizer::New();
      OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
      OptimizerPointer->SetParametersConvergenceTolerance(m_OptimizerParameters->GetParametersConvergenceToleranceAmoeba());
      OptimizerPointer->SetFunctionConvergenceTolerance(m_OptimizerParameters->GetFunctionConvergenceToleranceAmoeba());      
      itk::Array<double> simplexDeltaAmoeba = m_OptimizerParameters->GetSimplexDeltaAmoeba();
      OptimizerType::ParametersType simplexDelta( m_NumberTransformParameters );
      for (int i = 0; i < m_NumberTransformParameters; i++)
      {
        simplexDelta[i] = simplexDeltaAmoeba[i];
      }
      OptimizerPointer->AutomaticInitialSimplexOff();
      OptimizerPointer->SetInitialSimplexDelta( simplexDelta );
      OptimizerPointer->SetMaximumNumberOfIterations( m_OptimizerParameters->GetNumberOfIterationsAmoeba() );
      return OptimizerPointer.GetPointer();
    }
    else if (optimizer == OptimizerParameters::CONJUGATEGRADIENTOPTIMIZER)
    {
      itk::ConjugateGradientOptimizer::Pointer OptimizerPointer = itk::ConjugateGradientOptimizer::New();
      OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
      /*typedef  itk::ConjugateGradientOptimizer::InternalOptimizerType  vnlOptimizerType;
      vnlOptimizerType * vnlOptimizer = OptimizerPointer->GetOptimizer();
      vnlOptimizer->set_f_tolerance( 1e-3 );
      vnlOptimizer->set_g_tolerance( 1e-4 );
      vnlOptimizer->set_x_tolerance( 1e-8 ); 
      vnlOptimizer->set_epsilon_function( 1e-10 );
      vnlOptimizer->set_max_function_evals( m_Iterations );
      vnlOptimizer->set_check_derivatives( 3 );*/

      return OptimizerPointer.GetPointer();
    }
    else if (optimizer == OptimizerParameters::LBFGSOPTIMIZER)
    {
      itk::LBFGSOptimizer::Pointer OptimizerPointer = itk::LBFGSOptimizer::New();
      OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
      OptimizerPointer->SetGradientConvergenceTolerance( m_OptimizerParameters->GetGradientConvergenceToleranceLBFGS() );
      OptimizerPointer->SetLineSearchAccuracy( m_OptimizerParameters->GetLineSearchAccuracyLBFGS() );
      OptimizerPointer->SetDefaultStepLength( m_OptimizerParameters->GetDefaultStepLengthLBFGS() );
      OptimizerPointer->SetTrace(m_OptimizerParameters->GetTraceOnLBFGS());
      OptimizerPointer->SetMaximumNumberOfFunctionEvaluations( m_OptimizerParameters->GetNumberOfIterationsLBFGS() );
      return OptimizerPointer.GetPointer();
    }
OptimizerParameters::Pointer mitk::OptimizerFactory::GetOptimizerParameters (  ) [inline]

Returns the instance to the optimizer parameters class which holds all parameters for the new optimizer.

Definition at line 76 of file mitkOptimizerFactory.h.

    {
      return m_OptimizerParameters;
    }
static Pointer mitk::OptimizerFactory::New (  ) [static]

Referenced by GetOptimizer().

void mitk::OptimizerFactory::SetNumberOfTransformParameters ( int  numberTransformParameters )

Sets the number of transformParameters.

Definition at line 29 of file mitkOptimizerFactory.cpp.

Referenced by GetOptimizer().

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

Sets the instance to the optimizer parameters class which holds all parameters for the new optimizer.

Definition at line 68 of file mitkOptimizerFactory.h.

    {
      m_OptimizerParameters = optimizerParameters;
    }
The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines
Generated on Tue Oct 19 2010 16:20:38 for mitk by  doxygen 1.7.2