zxhOptimizerGradient.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 zxhOptimizerGradient_h
#define zxhOptimizerGradient_h

#define SetGradient2Transform(GradientObject,TransformObject) \
    { \
    if( zxh::IsAffTransform( TransformObject ) ) \
        GradientObject = (zxhTransformAffine*) TransformObject ; \
    else if ( zxh::IsFFDTransform( TransformObject ) ) \
        GradientObject = (zxhTransformFFD*) TransformObject ; \
    else if ( strcmp(TransformObject->GetTransformType().c_str(),"MRG") == 0 ) \
        GradientObject = (zxhGradientMultiRigid*) TransformObject ; \
    else if ( strcmp(TransformObject->GetTransformType().c_str(),"FLD") == 0 ) \
        GradientObject = (zxhTransformFieldGradient*) TransformObject ; \
    }
#define SetTransform2Gradient(TransformObject,GradientObject,TransformType) \
    { \
    if( zxh::IsAffTransform( TransformType ) ) \
        TransformObject = (zxhTransformAffine*) GradientObject ; \
    else if ( zxh::IsFFDTransform( TransformType ) ) \
        TransformObject = (zxhTransformFFD*) GradientObject ; \
    else if ( strcmp( TransformType->GetTransformType().c_str(),"MRG")==0 ) \
        TransformObject = (zxhGradientMultiRigid*) GradientObject ; \
    else if ( strcmp( TransformType->GetTransformType().c_str(),"FLD")==0 ) \
        TransformObject = (zxhTransformFieldGradient*) GradientObject ; \
    }
#include "zxhOptimizerBase.h"
#include "zxhGradientBase.h"
#include "zxhTransformFFDBase.h"
#include "zxhTransformFields.h"
#include "zxhGradientMultiRigid.h"
#include "zxhTransformFieldGradient.h"


class zxhOptimizerGradient : public zxhOptimizerBase
{
public:
    zxhOptimizerGradient(void);
    ~zxhOptimizerGradient(void);

    virtual void    SetTransform(zxhTransformBase*p);
    virtual void    SetGradientClassUsingObjectType(zxhTransformBase*pClassObject);


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

    virtual zxhOptimizerBase*   Clone(zxhOptimizerBase* &pRet);

    virtual void    SetRegularRate(float f)         {m_fRegularRate=f;}
    virtual float   GetRegularRate(void)            {return m_fRegularRate;};
    virtual void    SetSearchLength(float f)        {m_fSearchLength=f;}
    virtual float   GetSearchLength(void)           {return m_fSearchLength;}
    virtual void    SetRegularMinStepLength(float f){m_fRegularMinStepLength=f;};
    virtual float   GetRegularMinStepLength(void)   {return m_fRegularMinStepLength;}
    virtual void    SetRegriddingPortion(float f)       {m_fRegriddingPortion=f;};
    virtual float   GetRegriddingPortion(void)          {return m_fRegriddingPortion;};

    virtual void Run();
    virtual float AdvanceAlongGradient(zxhTransformBase*pGradientInfCur) ;
    virtual void SetSearchOptimalAlongGradient( int i )                     { m_iSearchOptimalAlongGradient = i ; } ;
    virtual int  GetSearchOptimalAlongGradient( )                           { return m_iSearchOptimalAlongGradient; } ;
    virtual void SetMaxLineSearchStep(int n)                                {m_nMaxLineSearchStep=n;};
    virtual int  GetMaxLineSearchStep()                                     {return m_nMaxLineSearchStep;};
    virtual bool AdjustParameters( bool forceconcatenation = false ) ;
    virtual bool ConcatenateTransforms() ;
    virtual bool ConcatenateFinalTransforms() { return ConcatenateTransforms();};
    virtual bool ConcatenateTransformsNUpdate();

protected:
    zxhGradientBase     *m_pGradient;

    float               m_fRegularRate;

    float               m_fSearchLength;

    float               m_fRegularMinStepLength;

    float               m_fRegriddingPortion;
    int                 m_iSearchOptimalAlongGradient ;
    int                 m_nMaxLineSearchStep ;

    virtual float   ComputeAndUpdateConjugateDirection( zxhTransformBase*gk_1,zxhTransformBase*gk,zxhTransformBase*dk_1,zxhTransformBase*dk ) ;


private:
    void    ConcatenateTransformsSetConcatenatedFieldForDim2Reg( zxhTransformFields* field )
    {
        if( m_pStructRegistration->m_iRegistrationDimension==2 && field->GetDimension() >= 3 )
        {
            zxhImageDataT<float> *pField = field->GetTransformFieldImages() ;
            const int *size = pField[0].GetImageSize();
            for( int it=0; it<size[3]; ++it )
            for( int iz=0; iz<size[2]; ++iz )
            for( int iy=0; iy<size[1]; ++iy )
            for( int ix=0; ix<size[0]; ++ix )
            {
                pField[0].SetPixelByGreyscale( ix,iy,iz,it, pField[0].GetPixelGreyscale(ix,iy,0,0) ) ;
                pField[1].SetPixelByGreyscale( ix,iy,iz,it, pField[1].GetPixelGreyscale(ix,iy,0,0) ) ;
                pField[2].SetPixelByGreyscale( ix,iy,iz,it, 0 ) ;
            }
            /*int * size = p->GetCtrGridSize() ;
            int nonzero=-1 ;
            for(int iz=0; iz<size[2]; ++iz )
            {
                for( int iy=0; iy<size[1]; ++iy )
                for( int ix=0; ix<size[0]; ++ix )
                {
                    if( p->GetCtrPntsWithoutCheck(ix,iy,iz,0)[0]!=0 || p->GetCtrPntsWithoutCheck(ix,iy,iz,0)[1]!=0 )
                        nonzero=iz ;
                    p->GetCtrPntsWithoutCheck(ix,iy,iz,0)[2]=0;
                }
                if( nonzero != -1 )
                    break;
            }
            if (nonzero == -1 ) return ;
            for( int iz=0; iz<size[2]; ++iz )
            for( int iy=0; iy<size[1]; ++iy )
            for( int ix=0; ix<size[0]; ++ix )
            {
                p->GetCtrPntsWithoutCheck(ix,iy,iz,0)[0]=p->GetCtrPntsWithoutCheck(ix,iy,nonzero,0)[0];
                p->GetCtrPntsWithoutCheck(ix,iy,iz,0)[1]=p->GetCtrPntsWithoutCheck(ix,iy,nonzero,0)[1];
                p->GetCtrPntsWithoutCheck(ix,iy,iz,0)[2]=0;
            }*/
        }
    }
};
#endif