itkUCLPowellOptimizer.h

Go to the documentation of this file.

/*=============================================================================

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). 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 in the top level directory for details.

=============================================================================*/

#ifndef itkUCLPowellOptimizer_h
#define itkUCLPowellOptimizer_h

#include <iostream>

#include <NifTKConfigure.h>
#include <niftkITKWin32ExportHeader.h>

#include <itkVector.h>
#include <itkMatrix.h>
#include <itkSingleValuedNonLinearOptimizer.h>
#include <itkSimilarityMeasure.h>

namespace itk
{

class NIFTKITK_WINEXPORT ITK_EXPORT UCLPowellOptimizer:
    public SingleValuedNonLinearOptimizer
{
public:
  typedef UCLPowellOptimizer                Self;
  typedef SingleValuedNonLinearOptimizer Superclass;
  typedef SmartPointer<Self>             Pointer;
  typedef SmartPointer<const Self>       ConstPointer;

  typedef SingleValuedNonLinearOptimizer::ParametersType
                                              ParametersType;
  
  itkNewMacro(Self);
 
  itkTypeMacro(UCLPowellOptimizer, SingleValuedNonLinearOptimizer );
  
  typedef  SingleValuedCostFunction         CostFunctionType;
  typedef  CostFunctionType::Pointer        CostFunctionPointer;

  itkSetMacro( Maximize, bool );
  itkGetConstReferenceMacro( Maximize, bool );

  itkSetMacro( MaximumIteration, unsigned int );
  itkGetConstReferenceMacro( MaximumIteration, unsigned int );

  itkSetMacro(MaximumLineIteration, unsigned int);
  itkGetConstMacro(MaximumLineIteration, unsigned int);

  itkSetMacro( StepLength, double );
  itkGetConstReferenceMacro( StepLength, double );

  itkSetMacro( StepTolerance, double );
  itkGetConstReferenceMacro( StepTolerance, double );

  itkSetMacro( ValueTolerance, double );
  itkGetConstReferenceMacro( ValueTolerance, double );

  itkGetConstReferenceMacro( CurrentCost, MeasureType );
  MeasureType GetValue() const { return this->GetCurrentCost(); }

  itkGetConstReferenceMacro( CurrentIteration, unsigned int);

  itkGetConstReferenceMacro( CurrentLineIteration, unsigned int);

  void StartOptimization() override;

  void StopOptimization() 
    { m_Stop = true; }

  itkGetMacro(CatchGetValueException, bool);
  itkSetMacro(CatchGetValueException, bool);

  itkGetMacro(MetricWorstPossibleValue, double);
  itkSetMacro(MetricWorstPossibleValue, double);
  
  itkGetMacro(ParameterTolerance, double); 
  itkSetMacro(ParameterTolerance, double); 

  const std::string GetStopConditionDescription() const override;

protected:
  UCLPowellOptimizer();
  UCLPowellOptimizer(const UCLPowellOptimizer&);
  virtual ~UCLPowellOptimizer();
  void PrintSelf(std::ostream& os, Indent indent) const override;

  itkSetMacro(CurrentCost, double);

  inline void SetLine(const ParametersType & origin,
               const vnl_vector<double> & direction)
  {
    for(unsigned int i=0; i<m_SpaceDimension; i++)
      {
      m_LineOrigin[i] = origin[i];
      // all in the same scale in the optimisation. 
      // m_LineDirection[i] = direction[i] / this->GetScales()[i];
      m_LineDirection[i] = direction[i];
      }
  }

  inline double GetLineValue(double x) const
  {
    UCLPowellOptimizer::ParametersType tempCoord( m_SpaceDimension );
    return this->GetLineValue(x, tempCoord);
  }

  double GetLineValue(double x, ParametersType & tempCoord) const;

  inline void   SetCurrentLinePoint(double x, double fx)
  {
    for(unsigned int i=0; i<m_SpaceDimension; i++)
      {
      this->m_CurrentPosition[i] = this->m_LineOrigin[i] + x * this->m_LineDirection[i];
      }
    if(m_Maximize)
      {
      this->SetCurrentCost(-fx);
      }
    else
      {
      this->SetCurrentCost(fx);
      }
    this->Modified();
  }

  inline void   Swap(double *a, double *b) const
  {
    double tf;
    tf = *a;
    *a = *b;
    *b = tf;
  }

  inline void   Shift(double *a, double *b, double *c, double d) const
  {
    *a = *b;
    *b = *c;
    *c = d;
  }

  inline void LineBracket(double * x1, double * x2, double * x3, double * f1, double * f2, double * f3)
  {
    UCLPowellOptimizer::ParametersType tempCoord( m_SpaceDimension );
    this->LineBracket( x1, x2, x3, f1, f2, f3, tempCoord);
  }

  virtual void   LineBracket(double *ax, double *bx, double *cx,
                             double *fa, double *fb, double *fc,
                             ParametersType & tempCoord);

  inline virtual void BracketedLineOptimize(double ax, double bx, double cx,
                        double fa, double functionValueOfb, double fc,
                        double * extX, double * extVal)
  {
    UCLPowellOptimizer::ParametersType tempCoord( m_SpaceDimension );
    this->BracketedLineOptimize( ax, bx, cx, fa, functionValueOfb, fc, extX, extVal, tempCoord);
  }

  virtual void   BracketedLineOptimize(double ax, double bx, double cx,
                                       double fa, double fb, double fc,
                                       double * extX, double * extVal,
                                       ParametersType & tempCoord);

  itkGetMacro(SpaceDimension, unsigned int);
  void SetSpaceDimension( unsigned int dim )
    {
    this->m_SpaceDimension = dim;
    this->m_LineDirection.set_size( dim );
    this->m_LineOrigin.set_size( dim );
    this->m_CurrentPosition.set_size( dim );
    this->Modified();
    }

  itkSetMacro(CurrentIteration, unsigned int);

  itkGetMacro(Stop, bool);
  itkSetMacro(Stop, bool);

  inline double GetMeasureOfParameterChange(ParametersType lastP, ParametersType p)
  {
    for(unsigned int i=0; i<m_SpaceDimension; i++)
    {
      lastP[i] = lastP[i]/this->GetScales()[i];
      p[i] = p[i]/this->GetScales()[i];
    }
    // Need to template this over the image types later. 
    typedef Image<float, 3> FloatImageType; 
    typedef SimilarityMeasure<FloatImageType, FloatImageType> SimilarityMeasureType; 

    return dynamic_cast<SimilarityMeasureType*>(this->m_CostFunction.GetPointer())->GetMeasureOfParameterChange(lastP, p); 
  }

private:
  unsigned int       m_SpaceDimension;

  unsigned int       m_CurrentIteration;
  unsigned int       m_CurrentLineIteration;

  unsigned int       m_MaximumIteration;
  unsigned int       m_MaximumLineIteration;

  bool               m_CatchGetValueException;
  double             m_MetricWorstPossibleValue;

  bool               m_Maximize;

  double             m_StepLength;
  double             m_StepTolerance;

  ParametersType     m_LineOrigin;
  vnl_vector<double> m_LineDirection;

  double             m_ValueTolerance;
  
  // Parameters tolerance. 
  double             m_ParameterTolerance; 

  MeasureType        m_CurrentCost;

  bool               m_Stop;

  std::ostringstream      m_StopConditionDescription;
}; // end of class

} // end of namespace itk

#endif