zxhMetricBase.h

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

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

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

#ifndef zxhMetricBase_h
#define zxhMetricBase_h

#include <string>
#include "zxhTransformBase.h"
#include "zxhImageGipl.h"
#include "zxhImageModelingBase.h"



class zxhMetricBase  
{

public:
    zxhMetricBase();

    virtual ~zxhMetricBase();

    virtual zxhMetricBase*  Clone(zxhMetricBase* &pRet);

    virtual std::string GetMetricType() = 0 ;
    virtual bool IsThisMetricType( std::string s )
    {
        return (strstr(s.c_str(),GetMetricType().c_str())!=NULL);
    }
    virtual bool IsThisMetricType( zxhMetricBase * pm )
    {   if( pm==0 ) return false ;
        return IsThisMetricType(pm->GetMetricType());
    }


    virtual bool    SetImage(zxhImageData*pImageTest,zxhImageData*pImageRef);
    virtual bool    SetMaskImage(zxhImageData*pMaskTest,zxhImageData*pMaskRef);
    virtual zxhImageData* GetMaskImageTest()                    { return m_pMaskTest ; };
    virtual zxhImageData* GetMaskImageRef()                     { return m_pMaskRef ; };
     
    virtual inline bool GetMaskByWorld(zxhImageData*pMaskImage,float fx,float fy,float fz,float ft)
    {
        if(pMaskImage==0||pMaskImage->GetNumberOfPixels()<=1) return true;
        float coo[] = {fx,fy,fz,ft} ;
        pMaskImage->WorldToImage( coo ) ;
        if(pMaskImage->InsideImage( zxh::round(coo[0]),zxh::round(coo[1]),zxh::round(coo[2]),zxh::round(coo[3]) )==false) return false;
        if(pMaskImage->GetPixelGreyscale(zxh::round(coo[0]),zxh::round(coo[1]),zxh::round(coo[2]),zxh::round(coo[3]))>ZXH_Mask)
            return true;
        return false;
    }
    virtual inline float GetWeightByWorld(zxhImageModelingBaseT<float,float>*pWeightModel,float fx,float fy,float fz,float ft)
    {
        if( pWeightModel==0 ||pWeightModel->GetImage()==0||pWeightModel->GetImage()->GetNumberOfPixels()==0) return 1 ;
        return pWeightModel->GetPixelFloatValueWithCheckBkByWorld(0, fx,fy,fz,ft) ;
    }

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

    virtual zxhImageModelingBaseT<float,float>* GetWegihtModelRef()             {return m_pWeightModelRef;};
    virtual zxhImageModelingBaseT<float,float>* GetWegihtModelTest()            {return m_pWeightModelTest;};
    virtual void SetWeightModelRef(zxhImageModelingBaseT<float,float>* p)       {m_pWeightModelRef=p;};
    virtual void SetWeightModelTest(zxhImageModelingBaseT<float,float>*p)       {m_pWeightModelTest=p;};

    virtual bool    SetImageModelingType(zxhImageModelingBase*pModelingTest,zxhImageModelingBase*pModelingRef);

    virtual bool    SetTransform(zxhTransformBase*pTr)                          {m_pTransform=pTr;return true;}

    virtual bool    SetForwardComposedTransform( zxhTransformBase*p )                   
    {m_pForwardComposedTransform = p; return true ; } ;
    
    virtual zxhTransformBase*   GetForwardComposedTransform()                   { return m_pForwardComposedTransform ; }

    virtual zxhTransformBase * GetTransform()                                   {return m_pTransform;};

    virtual void    SetDimension(int i)                             {m_iDimension=i;};

    virtual int GetDimension()                                      {return m_iDimension;}

    virtual void SetSamplingPhysical(float x,float y=1.0f,float z=1.0f,float t=1.0f);
    virtual const float * GetSamplingInterval()     {return m_afSamplingInterval;};
    virtual const float * GetSamplingPhysical()     {return m_afSamplingPhysical;};
    virtual int GetValue(zxhlfloat& fValue) =0;
    virtual std::string GetPrintString();

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

    virtual bool        GetWorldRoiFrom(float f[])
    {
        for( int id=0;id<m_iDimension;++id ) f[id]=m_afRoiWorld[0][id];
        return m_bSetRoiWorld ;
    };
    virtual bool        GetWorldRoiTo(float f[])
    {
        for( int id=0;id<m_iDimension;++id ) f[id]=m_afRoiWorld[1][id];
        return m_bSetRoiWorld ;
    };
    virtual bool        SetWorldRoi( float xf, float xt, float yf, float yt,
                                        float zf, float zt, float tf, float tt ) ;
    virtual bool    GetInnerRoiTest( float from[], float to[] ) ;
    virtual bool    WithinWorldROI( float wx, float wy, float wz, float wt ) ;

    virtual void    PreComputeTransformField();

    virtual void ResampleTestImagesSpacingPhysIntervel() ;
    virtual void ResampleImagesSpacingPhysIntervel() ;
    
protected: // protected method
    virtual bool TransformPointTo( float * from, float * to ) ;
    virtual void TransformWorldToWorld(const float * fromWorld, float * toWorld )  ;
 protected:
    int m_iDimension;

    zxhImageData  * m_pImageTest;

    zxhImageData  * m_pImageRef;

    zxhImageData  * m_pMaskTest;
    zxhImageData  * m_pMaskRef;

    zxhImageModelingBaseT<float,float>  *m_pWeightModelTest;

    zxhImageModelingBaseT<float,float>  *m_pWeightModelRef;

    zxhImageModelingBase    *m_pModelingTest;

    zxhImageModelingBase    *m_pModelingRef;

    zxhTransformBase*   m_pTransform;
    zxhTransformBase*   m_pForwardComposedTransform;
    float   m_afSamplingInterval[ImageDimensionMax];
    float   m_afSamplingPhysical[ImageDimensionMax];

    float       m_afRoiWorld[2][ImageDimensionMax] ;
    bool        m_bSetRoiWorld ;


    zxhImageData                m_imgRefImageOnXindex;
    zxhImageData                m_imgMaskTestRefOnXindex;
    zxhImageDataT<float>        m_aimgRefGradientOnXindex[ImageDimensionMax];


    zxhImageDataT<float>    m_aimgPreComputeTransformToWorld[ImageDimensionMax] ;
    bool                    m_bPreComputeTransformToWorld ;
    virtual bool            TransformPointToWorldUsingPreComputed(int x,int y,int z,int t, float wto[])
    {
        if ( m_bPreComputeTransformToWorld==false || m_aimgPreComputeTransformToWorld[0].InsideImage( x,y,z,t ) == false ) return false ;
        for( int id=0; id<m_iDimension; ++id )
            wto[id] = m_aimgPreComputeTransformToWorld[id].GetPixelGreyscale(x,y,z,t) ;
        return true ;
    }

};


#endif // zxhMetricBase_h