mitkRigidRegistrationObserver.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 MITKRIGIDREGISTRATIONOBSERVER_H
#define MITKRIGIDREGISTRATIONOBSERVER_H

#include "MitkRigidRegistrationExports.h"
#include "itkCommand.h"
#include "itkSingleValuedNonLinearOptimizer.h"
#include "mitkCommon.h"
#include <itkAmoebaOptimizer.h>
#include <itkConjugateGradientOptimizer.h>
#include <itkExhaustiveOptimizer.h>
#include <itkFRPROptimizer.h>
#include <itkGradientDescentOptimizer.h>
#include <itkLBFGSBOptimizer.h>
#include <itkLBFGSOptimizer.h>
#include <itkNormalVariateGenerator.h>
#include <itkOnePlusOneEvolutionaryOptimizer.h>
#include <itkPowellOptimizer.h>
#include <itkQuaternionRigidTransformGradientDescentOptimizer.h>
#include <itkRegularStepGradientDescentOptimizer.h>
#include <itkSPSAOptimizer.h>
#include <itkVersorRigid3DTransformOptimizer.h>
#include <itkVersorTransformOptimizer.h>

namespace mitk
{
  class MITKRIGIDREGISTRATION_EXPORT RigidRegistrationObserver : public itk::Command
  {
  public:
    typedef RigidRegistrationObserver Self;
    typedef itk::Command Superclass;
    typedef itk::SmartPointer<Self> Pointer;
    itkFactorylessNewMacro(Self) itkCloneMacro(Self)

      typedef itk::SingleValuedNonLinearOptimizer OptimizerType;
    typedef OptimizerType *OptimizerPointer;

    void Execute(itk::Object *caller, const itk::EventObject &event) override;

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

    void AddStepsToDo(int steps);

    void SetRemainingProgress(int steps);

    double GetCurrentOptimizerValue();

    itk::Array<double> GetCurrentTranslation();

    void SetStopOptimization(bool stopOptimization);

  protected:
    RigidRegistrationObserver();

    void HandleOptimizationIterationEvent(OptimizerType *optimizer);

  private:
    double m_OptimizerValue;
    itk::Array<double> m_Params;
    bool m_StopOptimization;
  };

  template <class RegistrationType>
  class MITKRIGIDREGISTRATION_EXPORT RigidRegistrationPyramidObserver : public itk::Command
  {
  public:
    typedef itk::RegularStepGradientDescentBaseOptimizer OptimizerType;

    mitkClassMacroItkParent(RigidRegistrationPyramidObserver<RegistrationType>, itk::Command)
      itkFactorylessNewMacro(Self) itkCloneMacro(Self)

        void Execute(itk::Object *caller, const itk::EventObject & /*event*/) override
    {
      RegistrationType *registration = dynamic_cast<RegistrationType *>(caller);

      if (registration == NULL)
        return;

      OptimizerType *optimizer = dynamic_cast<OptimizerType *>(registration->GetOptimizer());

      if (optimizer == NULL)
      {
        MITK_WARN("Pyramid.Registration.Command") << "No step adaptation possible with given optimizer, cast failed! ";
        return;
      }

      MITK_DEBUG << "\t - Pyramid level " << registration->GetCurrentLevel();

      if (registration->GetCurrentLevel() == 0)
      {
        MITK_INFO("Pyramid.Registration.Command") << "First pyramid resolution level: ";
        MITK_INFO("Pyramid.Registration.Command") << " Current settings: \n"
                                                  << " Step length: (" << optimizer->GetMinimumStepLength() << ","
                                                  << optimizer->GetMaximumStepLength()
                                                  << "), Tolerance: " << optimizer->GetGradientMagnitudeTolerance()
                                                  << " Iterations: " << optimizer->GetNumberOfIterations();
        return;
      }

      optimizer->SetMaximumStepLength(optimizer->GetMaximumStepLength() * 0.25f);
      optimizer->SetMinimumStepLength(optimizer->GetMinimumStepLength() * 0.1f);
      optimizer->SetGradientMagnitudeTolerance(optimizer->GetGradientMagnitudeTolerance() * 0.1f);
      optimizer->SetNumberOfIterations(optimizer->GetNumberOfIterations() * 1.5f);

      MITK_INFO("Pyramid.Registration.Command") << " Current settings: \n"
                                                << " Step length: (" << optimizer->GetMinimumStepLength() << ","
                                                << optimizer->GetMaximumStepLength()
                                                << "), Tolerance: " << optimizer->GetGradientMagnitudeTolerance()
                                                << " Iterations: " << optimizer->GetNumberOfIterations();
    }

    void Execute(const itk::Object * /*object*/, const itk::EventObject & /*event*/) override {}
  };

} // namespace mitk

#endif // MITKRIGIDREGISTRATIONOBSERVER_H