zxhTransformLocalAffines.h

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

  Program:   ZXH Registration Software
  Author:    Xiahai Zhuang
  Module:    $RCSfle: zxhTransformLocalAffines.h    $
  Language:  C++
  Date:      $Date: From  2008-01 $
  Version:   $Revision: 2.0 $

  Update log:


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

#ifndef zxhTransformLocalAffines_h
#define zxhTransformLocalAffines_h























#include "zxhTransformBase.h"
#include "zxhGradientBase.h"
#include "zxhTransformMultipleAffines.h"
#include "zxhImageData.h"
#include "zxhImageModelingLinear.h"
#include "zxhMetricMILocalAffines.h"
#include "zxhMetricPhaseLocalAffines.h"
#include <string>

class zxhMetricNV ;
class zxhMetricMILocalAffines ;
class zxhMetricPhaseLocalAffines;
class zxhTransformLocalAffines : public zxhTransformMultipleAffines
{
public:
    zxhTransformLocalAffines();
    virtual ~zxhTransformLocalAffines();

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

    virtual std::string GetPrintString();

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

    virtual zxhTransformBase*   Clone(zxhTransformBase*&pRet);

    virtual bool    PreComputeDistance2WeightAndSetModel();

    virtual void    TransformWorldToWorld(const float fVectorFromWorld[ImageDimensionMax],float fVectorToWorld[ImageDimensionMax])
    {
        float rx[] = { fVectorFromWorld[0], fVectorFromWorld[1], fVectorFromWorld[2], fVectorFromWorld[3] };
        LocalTransformWorldToWorld( fVectorFromWorld, rx ) ;
        zxhTransformAffine::TransformWorldToWorld( rx, fVectorToWorld );
    }
    virtual void    LocalTransformPointToWorld(float fVectorFrom[ImageDimensionMax],float fVectorToWorld[ImageDimensionMax]);
    virtual void    LocalTransformWorldToWorld(const float fVectorFromWorld[ImageDimensionMax],float fVectorToWorld[ImageDimensionMax]);
    virtual void    LocalTransformWorldToWorldByDisplace(const float fVectorFromWorld[ImageDimensionMax],float fVectorToWorld[ImageDimensionMax]);
    virtual void    LocalTransformWorldToWorldByAffine(const float fVectorFromWorld[ImageDimensionMax],float fVectorToWorld[ImageDimensionMax]);

    virtual bool    GetJacobianMatrixWorld(float fWorld[ImageDimensionMax],float pJacobian[ImageDimensionMax*ImageDimensionMax]);
    virtual bool    GetLocalAffineJacobianMatrixByWorld(float fWorld[ImageDimensionMax], float pJacobian[ImageDimensionMax*ImageDimensionMax]);
    virtual bool    GetLocalAffineJacobianMatrixByWorldForByDisplace(float fWorld[ImageDimensionMax], float pJacobian[ImageDimensionMax*ImageDimensionMax]);

    virtual float   GetMinLocalAffineJacobian( float wFrom[], float wTo[], float wIntval[], zxhImageData*pMaskTest=0, zxhImageData*pMaskRef=0 ) ;
    virtual float   GetMinLocalAffineJacobianOnTestImage( zxhImageData*pImageTest, float tFrom[], float tTo[], float tIntval[], zxhImageData*pMaskTest=0, zxhImageData*pMaskRef=0 ) ;


    /*  /////////////// setting of local regions ///////////////////////   */
    virtual void SetLocalRegions( zxhImageData*p );
    virtual zxhImageData* GetLocalRegions( )                        {return m_aLocalRegions ;};
    virtual bool    SetFileNameOfLocalRegions( std::string *s ) {for(int il=0;il<m_nNoLocalAffines;++il) m_astrFileNameOfLocalRegions[il]=s[il];m_bSetFileNameOfLocalRegions=true ;return true;};
    virtual const std::string * GetFileNameOfLocalRegions()     {return m_astrFileNameOfLocalRegions;};
    virtual bool    HasSetFileNameOfLocalRegions()                  {return m_bSetFileNameOfLocalRegions;};
    virtual bool SetLocalRegionsFromPreSetFileNames( );
    /*  /////////////// end setting of local regions ///////////////////////   */


    //virtual int ForwardMaskDilatedOverlap3D( float fDilate=0 ) ;//3D
    
    virtual void SetWorldRoi( float *wfrom, float *wto, int dimension )
    {
        m_iDimension = dimension ;
        for( int i=0; i<m_iDimension; ++i )
            m_afWorldRoi[0][i]=wfrom[i], m_afWorldRoi[1][i]=wto[i] ;
        m_bSetWorldRoi = true ;
    }
    virtual bool GetWorldRoi( float wfrom[], float wto[] ) ;
    virtual bool    WithinInterpolateRegionWorld( const float World[] ) ;
    virtual void    SetInterpolateByDisplacement(bool b)                {m_bInterpolateByDisplacement=b;};
    virtual bool    GetInterpolateByDisplacement()                      {return m_bInterpolateByDisplacement ;};

protected: //for methods
    inline  float   ComputeWeightFromDistance(float dis)
    {
        if( ZXH_LocalAffineExponent==1 ) return 1/dis;  
        if( ZXH_LocalAffineExponent==2 ) return 1/(dis*dis);
        return exp(-ZXH_LocalAffineExponent*log(dis));  
    }; 
    inline  float   ComputeDerivativeByDistance( float dis )
    { 
        if( ZXH_LocalAffineExponent==1 ) return -1/(dis*dis); 
        if( ZXH_LocalAffineExponent==2 ) return -2/(dis*dis*dis); 
        return -ZXH_LocalAffineExponent*exp((-ZXH_LocalAffineExponent-1)*log(dis));  
    }; 
    inline  float   ComputeWeightFromDistanceBoundary(float dis)
    {return ZXH_LocalAffineFacetWeighting*ComputeWeightFromDistance(dis);} 

    void    LocalTransformWorldToWorldOutlier(const float fVectorFromWorld[ImageDimensionMax],float fVectorToWorld[ImageDimensionMax]) ;
    float   ComputeRoiBoundaryWeightByWorld( const float fWorld[] )
    {
        float w = 0 ;
        for( int i=0; i<m_iDimension; ++i )
        {
            w += this->ComputeWeightFromDistanceBoundary( zxh::absf(fWorld[i] - m_afWorldRoi[0][i]) ) ;
            w += this->ComputeWeightFromDistanceBoundary( zxh::absf(m_afWorldRoi[1][i] - fWorld[i]) ) ;
        }
        return w ;
    }
    void    ComputeDerivativeWeightOfRoiBoundary( float NablaRoiW[], float co[], float fWorld[] )
    {
        for( int i=0; i<m_iDimension; ++i )
        { // \partial RoiD/ \paritial xi = 0 when 
            NablaRoiW[i] =  ZXH_LocalAffineFacetWeighting*this->ComputeDerivativeByDistance( zxh::absf(fWorld[i] - m_afWorldRoi[0][i]) ) ;//Dd/Dx=1
            NablaRoiW[i] -= ZXH_LocalAffineFacetWeighting*this->ComputeDerivativeByDistance( zxh::absf(m_afWorldRoi[1][i] - fWorld[i]) ) ;//Dd/Dx=(-1)
        }
    }
    void    PreComputeDistanceImageForLocalRegions();
    void    SetModelWeight();
protected:
    zxhImageData            *m_aLocalRegions ;
    std::string     m_astrFileNameOfLocalRegions[ZXH_LocalAffineMaxNumber] ;
    bool            m_bSetFileNameOfLocalRegions ;
    zxhImageData    m_aimgLoadLocalImagesFromPreSetFileNames[ZXH_LocalAffineMaxNumber] ;


    zxhImageDataT<float>    m_aLocalDistance2Weight[ZXH_LocalAffineMaxNumber];
    

    zxhImageDataT<float>    m_roiDistance2Weight ;// ---NOT in use m_aWeighting[nLocalAffine] point to boundary weight, and else 
    
    zxhImageModelingLinearT<float,float> m_aModelDistance2Weight[ZXH_LocalAffineMaxNumber+1];
    float       m_afWorldRoi[2][ImageDimensionMax] ;
    bool        m_bSetWorldRoi ;

    bool        m_bInterpolateByDisplacement ;

public:
    virtual void    SetIRBReg(bool b)               { m_bIRBReg=b; } ;
    virtual bool    GetIRBReg()                     { return m_bIRBReg; };
    virtual bool    ComputeGradientBasedIRBReg
        (
        zxhMetricMILocalAffines*pMetric,
        zxhTransformLocalAffines*pInfluence=0
        );
    virtual bool    ComputeGradientBasedAccReg
        (
        zxhMetricMILocalAffines*pMetric,
        zxhTransformLocalAffines*pInfluence=0
        ); 
    virtual bool    ComputeMetricGradient
        (
        zxhMetricBase*pMetric,
        zxhTransformBase*pInfluence=0
        );
     
protected:
    bool    m_bIRBReg ;
};

#endif