zxhTransformAffine.h

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

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

  Update log: 8th April 2007 add skew angle xy yx yz zy zx xz for 3D transformation,
              2011-03-20 checked
                    Y = Mskew x {Mscale x Mrotate x (X-Center) + Translate + Center} = K x {S x R x (X-C) + L + C}

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

#ifndef zxhTransformAffine_h
#define zxhTransformAffine_h


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

class zxhTransformAffine : public zxhTransformBase, public zxhGradientBase
{
    /*zxhushort     m_iDimension;
    zxhImageData*   m_pImageTest;
    zxhImageData*   m_pImageRef;*/
public:
    zxhTransformAffine();
    virtual ~zxhTransformAffine();

    virtual bool    SetTransformFromFile(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 std::string GetPrintString();

    virtual std::string GetTransformType(){return "AFF";}

    virtual zxhTransformBase*   Clone(zxhTransformBase*&pRet);
 
    float *     GetRotation()       {std::cerr<<"warning: unsafe access Affine parameters because of no automatic updatematrix, please use GetRotationValue\n";return m_afRotate;}
    float *     GetCenter()         {std::cerr<<"warning: unsafe access Affine parameters because of no automatic updatematrix, please use GetCenterValue\n";return m_afCenter;}
    float *     GetScaling()        {std::cerr<<"warning: unsafe access Affine parameters because of no automatic updatematrix, please use GetScalingValue\n";return m_afScaling;}
    float *     GetTranslation()    {std::cerr<<"warning: unsafe access Affine parameters because of no automatic updatematrix, please use GetTranslationValue\n";return m_afTranslate;}
    float *     GetSkewxy()         {std::cerr<<"warning: unsafe access Affine parameters because of no automatic updatematrix, please use GetSkewValue\n";return m_afSkewxy;};
    float *     GetSkewyz()         {std::cerr<<"warning: unsafe access Affine parameters because of no automatic updatematrix, please use GetSkewValue\n";return m_afSkewyz;};
    float *     GetSkewzx()         {std::cerr<<"warning: unsafe access Affine parameters because of no automatic updatematrix, please use GetSkewValue\n";return m_afSkewzx;};
    void    GetRotationValue( float rotation[ImageDimensionMax] );
    void    GetCenterValue( float center[ImageDimensionMax] );
    void    GetTranslationValue( float tranlsation[ImageDimensionMax] );
    void    GetScalingValue( float scaling[ImageDimensionMax] );
    void    GetSkewValue( float skewxy[2], float skewyz[2], float skewxz[2] );
    void        SetRotation(float afRotate[ImageDimensionMax]);
    void        SetCenter(float afCenter[ImageDimensionMax]);
    void        SetScaling(float afScaling[ImageDimensionMax]);
    void        SetTranslation(float afTranslate[ImageDimensionMax]);
    void        SetSkewxy(float afSkewxy[2]);
    void        SetSkewyz(float afSkewyz[2]);
    void        SetSkewzx(float afSkewzx[2]);

    virtual void    TransformWorldToWorld(const float fVectorFromWorld[ImageDimensionMax],float fVectorToWorld[ImageDimensionMax]);
    virtual void    InverseTransformWorld(float fVectorToWorld[ImageDimensionMax],float fVectorFromWorld[ImageDimensionMax]);

    virtual bool    GetJacobianMatrixWorld(float fWorld[ImageDimensionMax],float pJacobian[ImageDimensionMax*ImageDimensionMax]) ;
    virtual bool    GetJacobianMatrix(float fVector[ImageDimensionMax],float pJacobian[ImageDimensionMax*ImageDimensionMax])
    {return GetJacobianMatrixWorld(fVector, pJacobian);};
    virtual zxhTransformAffine & operator = (const zxhTransformAffine 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   GetMaxAbsValueFromParameters(void) ;
    virtual float   GetPointMutiplyAsVector(zxhTransformBase*);

    virtual void    UpdateMatrix();
    virtual void    UpdateInvertMatrix();
    virtual int     GetNoParameters()       {return 22;};
    virtual bool    SetParameterValue( int index, float f ) ;
    virtual float GetParameters(int index) ;
    virtual int GetDegreeOfFreedom () ;
    virtual int GetDOFWithValue( float f ) ;
    virtual float   GetMaxLocalMagnitudeAndNormalisation( bool bNormalisationByLocalMagnitude);
    virtual bool    AdvanceStep(zxhTransformBase*p, float f=1)  ;
    virtual float * GetMatrixPointer()          { return &m_afMatrix[0][0] ; } ;
    virtual float * GetInvertMatrixPointer()    { return &m_afInvertMatrix[0][0]; };

protected:
    //  m_bScalingFirst=true, then scaling,rotate by center,translate
    //bool      m_bScalingFirst;

    float   m_afRotate[ImageDimensionMax];
    float   m_afTranslate[ImageDimensionMax];
    float   m_afCenter[ImageDimensionMax];
    float   m_afScaling[ImageDimensionMax];
    float   m_afSkewxy[2];
    float   m_afSkewyz[2];
    float   m_afSkewzx[2];
    float   m_afMatrix[4][4];
    float   m_afInvertMatrix[4][4];



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

    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 void    SetUnitGradientOptimisation( bool b = true )    { m_bUnitGradient = b ; } ;
    virtual bool    GetUnitGradientOptimisation()                   { return m_bUnitGradient ; } ;
    virtual float   GetEstimateSubjectSize()                            { return m_fEstimateSubjectSize;};
    virtual void    SetEstimateSubjectSize(float f)                 { m_fEstimateSubjectSize = f;};
    virtual float   GetMaxDisplacementOfSubject() ;
    //bool  m_bUnitGradient ;
    //float m_fEstimateSubjectSize ;*/
};

#endif