zxhTransformMultipleAffines.h

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

  Program:   ZXH Registration Software
  Author:    Xiahai Zhuang
  Module:    $RCSfle: zxhTransformMultipleAffines.h    $
  Language:  C++
  Date:      $Date: From  2011-03 $
  Version:   $Revision: 2.2 $

  Update log:


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

#ifndef zxhTransformMultipleAffines_h
#define zxhTransformMultipleAffines_h







#include "zxhTransformBase.h"
#include "zxhGradientBase.h"
#include "zxhTransformAffine.h"
#include "zxhImageData.h"
#include "zxhImageModelingLinear.h"
#include <string>

class zxhTransformMultipleAffines : public zxhTransformAffine
{
public:
    zxhTransformMultipleAffines();
    virtual ~zxhTransformMultipleAffines();
    virtual zxhTransformBase*   Clone(zxhTransformBase*&pRet);

    virtual std::string GetPrintString();
    virtual std::string GetTransformType()                          {return "AFFS";} ;
    virtual bool    SetLocalMatrixFromFile(const char* pFile);
    virtual bool    SetTransformFromStream(std::ifstream& ifs);

    virtual bool    SetTransformIdentity();
    virtual bool    SetTransformAlignByCentre(int iCentre);
    virtual bool    SetTransformAlignByCentre(std::string sCentre)
    {
        if(strcmp(sCentre.c_str(),"centre")==0) return SetTransformAlignByCentre(2);
        if(strcmp(sCentre.c_str(),"gcentre")==0) return SetTransformAlignByCentre(3);
        return false;
    }
    virtual bool    SetImage(zxhImageData*pTest,zxhImageData*pRef);
    virtual void    SetLocalAffineRotateCentre( int iLocal, float *afwCenter )
    {   m_apLocalAffines[iLocal]->SetCenter( afwCenter ) ; } ;

    //virtual zxhTransformMultipleAffines & operator = (const zxhTransformMultipleAffines b);
    virtual bool    SetTransformPara(float f);
    virtual bool    GetAdd(zxhTransformBase*,zxhTransformBase*);
    virtual bool    Add(zxhTransformBase*) ;
    virtual bool    GetSubtract(zxhTransformBase*,zxhTransformBase*) ;
    virtual bool    Subtract(zxhTransformBase*) ;
    virtual bool    GetMultiply(zxhTransformBase*,float);
    virtual bool    Multiply(float) ;
    virtual bool    GetMultiplyByPara(zxhTransformBase*,zxhTransformBase*) ;
    virtual bool    MultiplyByPara(zxhTransformBase*) ;
    virtual bool    GetCompareByPara(zxhTransformBase*,float f=0) ;
    virtual bool    CompareByPara(float f=0) ;

    virtual float   GetMagnitudeAsVector(void);
    virtual float   GetMaxLocalMagnitudeAndNormalisation( bool bNormalisationByLocalMagnitude ) ;
    virtual float   GetMaxAbsValueFromParameters(void) ;
    virtual float   GetPointMutiplyAsVector(zxhTransformBase*);

    virtual void    UpdateMatrix();

    virtual int GetDegreeOfFreedom () ;
    virtual int GetDOFWithValue( float f ) ;

    virtual bool SetLocalAffines( zxhTransformAffine** p ) ;
    virtual bool SetNoOfLocalAffines( int n ) ;
    virtual bool SetNoOfLocalMatrix( int n ) ;
    virtual bool SetNoOfLocalAffines(int n, zxhTransformAffine*type) ;
    virtual int GetNoLocalAffines( )                    { return m_nNoLocalAffines; };
    virtual zxhTransformAffine** GetLocalAffines ()     { return m_apLocalAffines;};

    virtual bool    AdvanceStep(zxhTransformBase*p, float f=1)  ;

protected:
    int         m_nNoLocalAffines ;
    zxhTransformAffine      *m_apLocalAffines[ZXH_LocalAffineMaxNumber] ;


public:
    virtual int     GetNoParameters()       {return 22*(this->GetNoLocalAffines()+1) ;};
    virtual float   GetParameters(int index) ;
    virtual bool    SetParameterValue( int index, float f ) ;

    virtual void    InitialGradientDifferentialStep(zxhTransformAffine*pGrad,
                        float TranslateScale, float RotateScale, float ScalingScale,
                        float factor=1);
    virtual void    InitialGradientDifferentialStep(zxhTransformAffine*pGrad,
                        float TranslateScale[], float RotateScale[], float ScalingScale[],
                        float SkewScale, float factor=1);

    virtual bool    ComputeMetricGradient
        (
        zxhMetricBase*pMetric,
        zxhTransformBase*pInfluence=0
        );

protected:
    virtual bool    ComputeMetricGradientGlobalAffine
        (
        zxhMetricBase*pMetric,
        zxhTransformBase*pInfluence=0
        );
};

#endif