zxhTransformBase.h

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

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

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

#ifndef zxhTransformBase_H
#define zxhTransformBase_H

//#include "zxhMetricBase.h"
#include "zxhImageData.h"
#include <string.h>
#include <stdio.h>

//class zxhTransformGradientBase
//{
//public:
//  /// construction
//  zxhTransformGradientBase(){};
//  /// deconstruct
//  virtual ~zxhTransformGradientBase(){};
//};


class zxhTransformBase //: public zxhTransformGradientBase
{
public:
    zxhTransformBase();
    virtual ~zxhTransformBase();

    virtual bool    SetImage(zxhImageData*pTest,zxhImageData*pRef);

    virtual zxhImageData* GetTestImage()                            {return m_pImageTest;};
    virtual zxhImageData* GetRefImage()                             {return m_pImageRef;};

    virtual int GetDimension()                          {return m_iDimension;};

    virtual bool    SetDimension(int i)                 {m_iDimension=i;return true;};

    virtual std::string GetTransformType(){return "TFM";};//AFF,FFD,FFDMI,FLD

    virtual zxhTransformBase*   Clone(zxhTransformBase*&pRet);

    // abtract function

    virtual bool    TransformPointTo(float fVectorFrom[ImageDimensionMax],float fVectorTo[ImageDimensionMax])
    {
        this->TransformPointToWorld(fVectorFrom,fVectorTo);
        this->AdjustWorldToRefImage(fVectorTo);
        if( m_pImageRef ) return ! m_pImageRef->InsideImage( fVectorTo );
        return false ;
    };
    virtual void    TransformPointToWorld(float fVectorFrom[ImageDimensionMax],float fVectorToWorld[ImageDimensionMax])
    {
        float fv[]={fVectorFrom[0],fVectorFrom[1],fVectorFrom[2],fVectorFrom[3]};
        this->AdjustTestImageToWorld(fv);
        this->TransformWorldToWorld( fv, fVectorToWorld );
    };
    virtual void    TransformWorldToWorld(const float fVectorFromWorld[ImageDimensionMax],float fVectorToWorld[ImageDimensionMax])=0;

    virtual void    InverseTransformWorld( float fVectorToWorld[ImageDimensionMax],float fVectorFromWorld[ImageDimensionMax])
    {std::cerr<<"error: inverse transform world has not be implemented.\n" ; return ;};

    //virtual bool  GetJacobianMatrix(float fVector[ImageDimensionMax],float* xJacobian[ImageDimensionMax]){return false;};
    virtual bool    GetJacobianMatrix(float fVector[ImageDimensionMax],float pJacobian[ImageDimensionMax*ImageDimensionMax]);
    virtual bool    GetJacobianMatrixWorld(float fWorld[ImageDimensionMax],float pJacobian[ImageDimensionMax*ImageDimensionMax]);

    virtual void    TransformIntensityGradientVectorTo( float fVectorFrom[ImageDimensionMax],float fVectorTo[ImageDimensionMax],float* fWorldFrom ) ;
     
    virtual void    InverseTransformIntensityGradientVector( float fVectorRef[ImageDimensionMax],float fInverseVectorTest[ImageDimensionMax],float* fWorldTest ) ;
     

    virtual bool    SetTransformPara(float);
    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 float   GetMagnitudeAsVector();


    /* *** validate results on FFDs:
    /* 1) [X] using assume each control point has own support local regions to avoid turbulent changes--> reduce accuracy
    /* 2) [X] using a global maximal mag from all CPs for normalization, a big turbulent changes dominant the optimization length
     *    --> reduce robustness in registration where large deformation fields are needed
     * ****************************************/
    virtual float   GetMaxLocalMagnitudeAndNormalisation( bool bNormalisationByLocalMagnitude )         
    {
        float fmag = GetMagnitudeAsVector();
        if( fmag>0 ) this->Multiply(1/fmag) ;
        return fmag ;
    }; 
    /*virtual void  SetNormalisationByLocalMagnitude( bool b )              
    {   m_bNormalisationByLocalMagnitude    = b ; } 
    virtual bool    GetNormalisationByLocalMagnitude()              
    {   return m_bNormalisationByLocalMagnitude ; }*/
    ;
    virtual float   GetMaxAbsValueFromParameters() ;

    virtual float   GetPointMutiplyAsVector(zxhTransformBase*) ;

    virtual bool    SetTransformIdentity()=0;
    virtual bool    SetTransformFromStream(std::ifstream & ifs);
    virtual bool    SetTransformFromFile(const char* pFile);
    virtual std::string GetTransformFileName()          { return m_strFileName ; } ;

    virtual std::string GetPrintString();

    virtual bool SaveTransform2Disc( std::string sFileNameWithoutExt ) ;

    virtual float Guarantee1To1(void)   { return -1 ; };
    virtual void SetGuarantee1To1Effected(bool b=true)              {m_bEffect1to1  = b;};
    virtual bool    AdvanceStep(zxhTransformBase*p, float f=1)                  
    {   zxhTransformBase *pf=0 ; p->Clone( pf ) ; pf->GetMultiply(p,f) ;
        bool b=this->Add(pf) ; delete pf ; return b ; 
    };

    inline void AdjustTestImageToWorld(float afTest[])
    {
        if(m_pImageTest)
            m_pImageTest->ImageToWorld(afTest) ;
        else
        {   std::cerr<<"error: no set transform images to AdjustTestToworld\n" ; exit(1); };
    }
    inline void AdjustWorldToRefImage(float afRef[])
    {
        if(m_pImageRef)
            m_pImageRef->WorldToImage(afRef);
        else
        {   std::cerr<<"error: no set transform images to AdjustToRefGrid\n" ; exit(1); } ;
    } ;

    //virtual bool  GetTransformationDerivativeByParameter(float g[4], int index, float Worldx[]);
    virtual int     GetNoParameters()=0;
    virtual float   GetParameters(int index)=0 ;
    virtual bool    SetParameterValue( int index, float f ) = 0 ;
    virtual int GetDegreeOfFreedom ()           {return GetNoParameters() ; };
    virtual int GetDOFWithValue( float f )      
    { 
        int idof=0 , no=GetNoParameters(); 
        for( int index=0; index<no; ++index )
            if( GetParameters(index) >= f ) idof++ ;
        return idof ;   
    };
    virtual int GetActiveDof()                  { return GetDOFWithValue(ZXH_FloatPrecision) ;};
protected:
    const static unsigned int static_buffer_size_of_base=1024;

    int             m_iDimension;

    bool            m_bEffect1to1;

    zxhImageData*       m_pImageTest;
    zxhImageData*       m_pImageRef;
    std::string         m_strFileName ;
    
}  ;

namespace zxh{
bool TransformWorld2WorldByCollection( zxhTransformBase*pListTransform[], int nTransform,
         int dimension,const float fWorldFrom[ImageDimensionMax],float fWorldTo[ImageDimensionMax]);

bool IsAffTransform(zxhTransformBase *pTrans);
bool IsAffineMatrix(zxhTransformBase *pTrans);
bool IsFFDTransform(zxhTransformBase*pTrans);
bool IsFFDTransform(std::string type);
enum ZXH_TransformType{TransformTypeRigid=0, TransformTypeScale=1, TransformTypeAffine=2, TransformTypeFFD=3,
TransformTypeSkew=5,
TransformTypeLocalAffine=10};

}
#endif //