itkPowellOptimizer.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkPowellOptimizer.h,v $
  Language:  C++
  Date:      $Date: 2009-06-24 12:02:54 $
  Version:   $Revision: 1.12 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkPowellOptimizer_h
#define __itkPowellOptimizer_h

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

namespace itk
{

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

  typedef SingleValuedNonLinearOptimizer::ParametersType
                                              ParametersType;
  
  itkNewMacro(Self);

  itkTypeMacro(PowellOptimizer, 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();

  void StopOptimization() 
    { m_Stop = true; }

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

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

  const std::string GetStopConditionDescription() const;

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

  itkSetMacro(CurrentCost, double);

  void SetLine(const ParametersType & origin,
               const vnl_vector<double> & direction);

  double GetLineValue(double x) const;

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

  void   SetCurrentLinePoint(double x, double fx);

  void   Swap(double *a, double *b) const;

  void   Shift(double *a, double *b, double *c, double d) const;

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

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

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

  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);

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;

  MeasureType        m_CurrentCost;

  bool               m_Stop;

  OStringStream      m_StopConditionDescription;
}; // end of class

} // end of namespace itk

#endif