zxhOptimizerBase.h

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

  Program:   ZXH Registration Software
  Author:    Xiahai Zhuang
  Module:    $RCSfle: zxhOptimizerBase.h    $
  Language:  C++
  Date:      $Date: From  2004-01 $
  Version:   $Revision: 1.0, 2.0 $

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

#ifndef zxhOptimizerBase_h
#define zxhOptimizerBase_h

#include "zxhTransformBase.h"
#include "zxhImageData.h"
#include "zxhMetricBase.h"
#include "zxhRegistrationStruct.h"
#include <string>

class zxhOptimizerBase
{
public:
    zxhOptimizerBase();

    virtual ~zxhOptimizerBase();

    virtual void    SetMetric(zxhMetricBase*p)                  {m_pMetric=p;};
    virtual void    SetTransform(zxhTransformBase*p)            {m_pTransform=p;}
    virtual void    SetTransformInfluence(zxhTransformBase*p)   {m_pTransformInf=p;};
    virtual void    SetDirection(float f)                       {m_fDirection=f;};
    virtual void    SetMaxStep( int i)  ;

    virtual std::string GetPrintString();

    virtual bool        SetOptimizerFromStream(std::ifstream & ifs);

    virtual zxhlfloat       GetResultValue()                    {return m_fValueCur;};

    virtual unsigned int        GetCurrentStep()        {return m_iStepCount;};

    virtual bool    GetIsStop()                         {return m_bStop;};

    virtual zxhTransformBase* GetTransform()            {return m_pTransform;};

    virtual zxhTransformBase* GetTransformInfluence()   {return m_pTransformInf;};

    virtual zxhMetricBase*    GetMetric()               {return m_pMetric;};

    virtual float             GetDirection()            {return m_fDirection;};

    virtual void Run()=0;
    //virtual bool AdvanceSteps(){return false;}; // return whether to stop

    virtual zxhOptimizerBase*   Clone(zxhOptimizerBase* &pRet);

    virtual void    SetResultSaveString( std::string s )    { m_sResultSave = s ; } ;
    virtual std::string GetResultSaveString()               { return m_sResultSave ; } ;
    virtual void    SetStructRegistration(zxhRegistrationStruct*p)      {m_pStructRegistration=p;};
    virtual zxhRegistrationStruct* GetStructRegistration()                  {return m_pStructRegistration;};
    virtual void    SetAccumulatedDecreaseStepsForStop( int i)              { m_nAccumulatedStop=i;};
    virtual int     GetAccumulatedDecreaseStepsForStop()                    { return m_nAccumulatedStop;};


protected:
    float           m_fDirection;

    unsigned int    m_iMaxStep;

    zxhTransformBase*m_pTransform;

    zxhTransformBase*m_pTransformInf;

    zxhMetricBase   *m_pMetric;

    zxhlfloat           m_fValueCur;

    zxhlfloat           m_fValuePreMax;

    int             m_iAccumulatedValueDecrease;
    int             m_nAccumulatedStop ;
    unsigned int    m_iStepCount;

    bool            m_bStop;

    std::string     m_sResultSave ;
    zxhRegistrationStruct*  m_pStructRegistration ;
};

#endif // (zxhOptimizerBase_h)