mitk: mitkOptimizerFactory.cpp Source File

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003 Program:   Medical Imaging & Interaction Toolkit
00004 Language:  C++
00005 Date:      $Date$
00006 Version:   $Revision$
00007 
00008 Copyright (c) German Cancer Research Center, Division of Medical and
00009 Biological Informatics. All rights reserved.
00010 See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.
00011 
00012 This software is distributed WITHOUT ANY WARRANTY; without even
00013 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00014 PURPOSE.  See the above copyright notices for more information.
00015 
00016 =========================================================================*/
00017 
00018 #include "mitkOptimizerFactory.h"
00019 #include "mitkOptimizerParameters.h"
00020 
00021 #include <itkExhaustiveOptimizer.h>
00022 #include <itkGradientDescentOptimizer.h>
00023 #include <itkQuaternionRigidTransformGradientDescentOptimizer.h>
00024 #include <itkLBFGSBOptimizer.h>
00025 #include <itkOnePlusOneEvolutionaryOptimizer.h>
00026 #include <itkNormalVariateGenerator.h>
00027 #include <itkPowellOptimizer.h>
00028 #include <itkFRPROptimizer.h>
00029 #include <itkRegularStepGradientDescentOptimizer.h>
00030 #include <itkVersorRigid3DTransformOptimizer.h>
00031 #include <itkVersorTransformOptimizer.h>
00032 #include <itkAmoebaOptimizer.h>
00033 #include <itkConjugateGradientOptimizer.h>
00034 #include <itkLBFGSOptimizer.h>
00035 #include <itkSPSAOptimizer.h>
00036 
00037 namespace mitk {
00038 
00039   OptimizerFactory::OptimizerFactory() : m_OptimizerParameters(NULL), m_NumberTransformParameters(16)
00040   {
00041   }
00042 
00043   OptimizerFactory::~OptimizerFactory()
00044   {
00045   }
00046 
00047   void OptimizerFactory::SetNumberOfTransformParameters(int numberTransformParameters)
00048   {
00049     m_NumberTransformParameters = numberTransformParameters;
00050   }
00051 
00052   OptimizerFactory::OptimizerType::Pointer OptimizerFactory::GetOptimizer( )
00053   {
00054     if( m_OptimizerParameters.IsNull() ) 
00055     {
00056       MITK_ERROR << "No parameters set! Returning\n";
00057       return NULL;
00058     }
00059     int optimizer = m_OptimizerParameters->GetOptimizer();
00060     if (optimizer == OptimizerParameters::EXHAUSTIVEOPTIMIZER)
00061     {
00062       itk::ExhaustiveOptimizer::Pointer OptimizerPointer = itk::ExhaustiveOptimizer::New();
00063       OptimizerPointer->SetStepLength( m_OptimizerParameters->GetStepLengthExhaustive() );
00064       itk::ExhaustiveOptimizer::StepsType steps( m_NumberTransformParameters );
00065       for (int i = 0; i < m_NumberTransformParameters; i++)
00066       {
00067         steps[i] = m_OptimizerParameters->GetNumberOfStepsExhaustive();
00068       }
00069       
00070       OptimizerPointer->SetNumberOfSteps( steps );
00071 
00072       return OptimizerPointer.GetPointer();
00073     }
00074     else if (optimizer == OptimizerParameters::GRADIENTDESCENTOPTIMIZER)
00075     {
00076       itk::GradientDescentOptimizer::Pointer OptimizerPointer = itk::GradientDescentOptimizer::New();
00077       OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize());
00078       OptimizerPointer->SetLearningRate(m_OptimizerParameters->GetLearningRateGradientDescent());
00079       OptimizerPointer->SetNumberOfIterations( m_OptimizerParameters->GetNumberOfIterationsGradientDescent() );
00080       return OptimizerPointer.GetPointer();
00081     }
00082     else if (optimizer == OptimizerParameters::QUATERNIONRIGIDTRANSFORMGRADIENTDESCENTOPTIMIZER)
00083     {
00084       itk::QuaternionRigidTransformGradientDescentOptimizer::Pointer OptimizerPointer = itk::QuaternionRigidTransformGradientDescentOptimizer::New();
00085       OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize());  
00086       OptimizerPointer->SetLearningRate(m_OptimizerParameters->GetLearningRateQuaternionRigidTransformGradientDescent());
00087       OptimizerPointer->SetNumberOfIterations( m_OptimizerParameters->GetNumberOfIterationsQuaternionRigidTransformGradientDescent() );
00088       return OptimizerPointer.GetPointer();
00089     }
00090     else if (optimizer == OptimizerParameters::LBFGSBOPTIMIZER)
00091     {
00092       itk::LBFGSBOptimizer::Pointer OptimizerPointer = itk::LBFGSBOptimizer::New();
00093       // Set up boundary conditions
00094       itk::LBFGSBOptimizer::BoundValueType lower(12);
00095       itk::LBFGSBOptimizer::BoundValueType upper(12);
00096       itk::LBFGSBOptimizer::BoundSelectionType select(12);
00097 
00098       lower.Fill( -1 );
00099       upper.Fill( 10 );
00100       select.Fill( 2 );
00101 
00102       OptimizerPointer->SetLowerBound( lower );
00103       OptimizerPointer->SetUpperBound( upper );
00104       OptimizerPointer->SetBoundSelection( select );
00105       OptimizerPointer->SetCostFunctionConvergenceFactor(1e+1);
00106       OptimizerPointer->SetMaximumNumberOfCorrections(5);
00107       OptimizerPointer->SetProjectedGradientTolerance(1e-5);
00108       OptimizerPointer->SetMaximumNumberOfEvaluations(500);
00109       OptimizerPointer->SetMaximumNumberOfIterations( 200 );
00110       return OptimizerPointer.GetPointer();
00111     }
00112     else if (optimizer == OptimizerParameters::ONEPLUSONEEVOLUTIONARYOPTIMIZER)
00113     {
00114       itk::OnePlusOneEvolutionaryOptimizer::Pointer OptimizerPointer = itk::OnePlusOneEvolutionaryOptimizer::New();
00115       OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
00116       itk::Statistics::NormalVariateGenerator::Pointer generator = itk::Statistics::NormalVariateGenerator::New();
00117       generator->Initialize(12345);
00118       OptimizerPointer->SetNormalVariateGenerator(generator);
00119       OptimizerPointer->SetGrowthFactor(m_OptimizerParameters->GetGrowthFactorOnePlusOneEvolutionary());
00120       OptimizerPointer->SetShrinkFactor(m_OptimizerParameters->GetShrinkFactorOnePlusOneEvolutionary());
00121       OptimizerPointer->SetEpsilon(m_OptimizerParameters->GetEpsilonOnePlusOneEvolutionary());
00122       OptimizerPointer->SetInitialRadius(m_OptimizerParameters->GetInitialRadiusOnePlusOneEvolutionary());
00123       OptimizerPointer->SetMaximumIteration(m_OptimizerParameters->GetNumberOfIterationsOnePlusOneEvolutionary());
00124       return OptimizerPointer.GetPointer();
00125     }
00126     else if (optimizer == OptimizerParameters::POWELLOPTIMIZER)
00127     {
00128       itk::PowellOptimizer::Pointer OptimizerPointer = itk::PowellOptimizer::New();
00129       OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
00130       OptimizerPointer->SetStepLength( m_OptimizerParameters->GetStepLengthPowell() );
00131       OptimizerPointer->SetStepTolerance( m_OptimizerParameters->GetStepTolerancePowell() );
00132       OptimizerPointer->SetValueTolerance( m_OptimizerParameters->GetValueTolerancePowell() );
00133       OptimizerPointer->SetMaximumIteration( m_OptimizerParameters->GetNumberOfIterationsPowell() );
00134       return OptimizerPointer.GetPointer();
00135     }
00136     else if (optimizer == OptimizerParameters::FRPROPTIMIZER)
00137     {
00138       itk::FRPROptimizer::Pointer OptimizerPointer = itk::FRPROptimizer::New();
00139       OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
00140       OptimizerPointer->SetStepLength(m_OptimizerParameters->GetStepLengthFRPR());
00141       if (m_OptimizerParameters->GetFletchReevesFRPR())
00142       {
00143         OptimizerPointer->SetToFletchReeves();
00144       }
00145       else if (m_OptimizerParameters->GetPolakRibiereFRPR())
00146       {
00147         OptimizerPointer->SetToPolakRibiere();
00148       }
00149       OptimizerPointer->SetMaximumIteration( m_OptimizerParameters->GetNumberOfIterationsFRPR() );
00150       return OptimizerPointer.GetPointer();
00151     }
00152     else if (optimizer == OptimizerParameters::REGULARSTEPGRADIENTDESCENTOPTIMIZER)
00153     {
00154       itk::RegularStepGradientDescentOptimizer::Pointer OptimizerPointer = itk::RegularStepGradientDescentOptimizer::New();
00155       OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
00156       OptimizerPointer->SetGradientMagnitudeTolerance( m_OptimizerParameters->GetGradientMagnitudeToleranceRegularStepGradientDescent() );
00157       OptimizerPointer->SetMinimumStepLength( m_OptimizerParameters->GetMinimumStepLengthRegularStepGradientDescent() );
00158       OptimizerPointer->SetMaximumStepLength( m_OptimizerParameters->GetMaximumStepLengthRegularStepGradientDescent() );
00159       OptimizerPointer->SetNumberOfIterations( m_OptimizerParameters->GetNumberOfIterationsRegularStepGradientDescent() );
00160       OptimizerPointer->SetRelaxationFactor( m_OptimizerParameters->GetRelaxationFactorRegularStepGradientDescent() );
00161       return OptimizerPointer.GetPointer();
00162     }
00163     else if (optimizer == OptimizerParameters::VERSORRIGID3DTRANSFORMOPTIMIZER)
00164     {
00165       itk::VersorRigid3DTransformOptimizer::Pointer OptimizerPointer = itk::VersorRigid3DTransformOptimizer::New();
00166       OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
00167       OptimizerPointer->SetGradientMagnitudeTolerance( m_OptimizerParameters->GetGradientMagnitudeToleranceVersorRigid3DTransform() );
00168       OptimizerPointer->SetMinimumStepLength( m_OptimizerParameters->GetMinimumStepLengthVersorRigid3DTransform() );
00169       OptimizerPointer->SetMaximumStepLength( m_OptimizerParameters->GetMaximumStepLengthVersorRigid3DTransform() );
00170       OptimizerPointer->SetNumberOfIterations( m_OptimizerParameters->GetNumberOfIterationsVersorRigid3DTransform() );
00171       return OptimizerPointer.GetPointer();
00172     }
00173     else if (optimizer == OptimizerParameters::VERSORTRANSFORMOPTIMIZER)
00174     {
00175       itk::VersorTransformOptimizer::Pointer OptimizerPointer = itk::VersorTransformOptimizer::New();
00176       OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
00177       OptimizerPointer->SetGradientMagnitudeTolerance( m_OptimizerParameters->GetGradientMagnitudeToleranceVersorTransform() );
00178       OptimizerPointer->SetMinimumStepLength( m_OptimizerParameters->GetMinimumStepLengthVersorTransform() );
00179       OptimizerPointer->SetMaximumStepLength( m_OptimizerParameters->GetMaximumStepLengthVersorTransform() );
00180       OptimizerPointer->SetNumberOfIterations( m_OptimizerParameters->GetNumberOfIterationsVersorTransform() );
00181       return OptimizerPointer.GetPointer();
00182     }
00183     else if (optimizer == OptimizerParameters::AMOEBAOPTIMIZER)
00184     {
00185       itk::AmoebaOptimizer::Pointer OptimizerPointer = itk::AmoebaOptimizer::New();
00186       OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
00187       OptimizerPointer->SetParametersConvergenceTolerance(m_OptimizerParameters->GetParametersConvergenceToleranceAmoeba());
00188       OptimizerPointer->SetFunctionConvergenceTolerance(m_OptimizerParameters->GetFunctionConvergenceToleranceAmoeba());      
00189       itk::Array<double> simplexDeltaAmoeba = m_OptimizerParameters->GetSimplexDeltaAmoeba();
00190       OptimizerType::ParametersType simplexDelta( m_NumberTransformParameters );
00191       for (int i = 0; i < m_NumberTransformParameters; i++)
00192       {
00193         simplexDelta[i] = simplexDeltaAmoeba[i];
00194       }
00195       OptimizerPointer->AutomaticInitialSimplexOff();
00196       OptimizerPointer->SetInitialSimplexDelta( simplexDelta );
00197       OptimizerPointer->SetMaximumNumberOfIterations( m_OptimizerParameters->GetNumberOfIterationsAmoeba() );
00198       return OptimizerPointer.GetPointer();
00199     }
00200     else if (optimizer == OptimizerParameters::CONJUGATEGRADIENTOPTIMIZER)
00201     {
00202       itk::ConjugateGradientOptimizer::Pointer OptimizerPointer = itk::ConjugateGradientOptimizer::New();
00203       OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
00204       /*typedef  itk::ConjugateGradientOptimizer::InternalOptimizerType  vnlOptimizerType;
00205       vnlOptimizerType * vnlOptimizer = OptimizerPointer->GetOptimizer();
00206       vnlOptimizer->set_f_tolerance( 1e-3 );
00207       vnlOptimizer->set_g_tolerance( 1e-4 );
00208       vnlOptimizer->set_x_tolerance( 1e-8 ); 
00209       vnlOptimizer->set_epsilon_function( 1e-10 );
00210       vnlOptimizer->set_max_function_evals( m_Iterations );
00211       vnlOptimizer->set_check_derivatives( 3 );*/
00212 
00213       return OptimizerPointer.GetPointer();
00214     }
00215     else if (optimizer == OptimizerParameters::LBFGSOPTIMIZER)
00216     {
00217       itk::LBFGSOptimizer::Pointer OptimizerPointer = itk::LBFGSOptimizer::New();
00218       OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
00219       OptimizerPointer->SetGradientConvergenceTolerance( m_OptimizerParameters->GetGradientConvergenceToleranceLBFGS() );
00220       OptimizerPointer->SetLineSearchAccuracy( m_OptimizerParameters->GetLineSearchAccuracyLBFGS() );
00221       OptimizerPointer->SetDefaultStepLength( m_OptimizerParameters->GetDefaultStepLengthLBFGS() );
00222       OptimizerPointer->SetTrace(m_OptimizerParameters->GetTraceOnLBFGS());
00223       OptimizerPointer->SetMaximumNumberOfFunctionEvaluations( m_OptimizerParameters->GetNumberOfIterationsLBFGS() );
00224       return OptimizerPointer.GetPointer();
00225     }
00226     else if (optimizer == OptimizerParameters::SPSAOPTIMIZER)
00227     {
00228       itk::SPSAOptimizer::Pointer OptimizerPointer = itk::SPSAOptimizer::New();
00229       OptimizerPointer->SetMaximize( m_OptimizerParameters->GetMaximize() );
00230       OptimizerPointer->Seta( m_OptimizerParameters->GetaSPSA() );
00231       OptimizerPointer->SetA( m_OptimizerParameters->GetASPSA() );
00232       OptimizerPointer->SetAlpha( m_OptimizerParameters->GetAlphaSPSA() );
00233       OptimizerPointer->Setc( m_OptimizerParameters->GetcSPSA() );
00234       OptimizerPointer->SetGamma( m_OptimizerParameters->GetGammaSPSA() );
00235       OptimizerPointer->SetTolerance(m_OptimizerParameters->GetToleranceSPSA());
00236       OptimizerPointer->SetStateOfConvergenceDecayRate(m_OptimizerParameters->GetStateOfConvergenceDecayRateSPSA());
00237       OptimizerPointer->SetMinimumNumberOfIterations(m_OptimizerParameters->GetMinimumNumberOfIterationsSPSA());
00238       OptimizerPointer->SetNumberOfPerturbations(m_OptimizerParameters->GetNumberOfPerturbationsSPSA());
00239       OptimizerPointer->SetMaximumNumberOfIterations(m_OptimizerParameters->GetNumberOfIterationsSPSA());
00240       return OptimizerPointer.GetPointer();
00241     }
00242     return NULL;
00243   }
00244 } // end namespace