zxhMetricMIConstraint.h

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

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

=========================================================================*/
#ifndef zxhMetricMIConstraint_h
#define zxhMetricMIConstraint_h

#include "zxh.h"
#include "zxhMetricMI.h"
#include "zxhTransformFFDBase.h"
#include <math.h>

class zxhMetricMIConstraint :
    public zxhMetricMI
{
public:
    zxhMetricMIConstraint(void);
    ~zxhMetricMIConstraint(void);

    virtual std::string GetMetricType() {return zxhMetricMI::GetMetricType()+"_CNST_"; } ;

    virtual zxhMetricBase* Clone( zxhMetricBase * & pRet );
    virtual int  GetValue(zxhlfloat&fValue);

    /* Zhu07 and Rohlfing03 impressibility term:
        Gaussian ( (V-Vref)/(1/120Vref), 0, 1) and 1/N\sumLog(|J|) , but we threshold on Gaussian(\sigma,u,\sigma)*/
    virtual     zxhlfloat GetSumImpressibilityTerm(zxhlfloat Orig, zxhlfloat After ) ;
    virtual     zxhlfloat GetVolumeFromRef( zxhTransformBase * pTrans,
                    float xfWorldFrom,float xfWorldTo,float yfWorldFrom,float yfWorldTo,
                    float zfWorldFrom,float zfWorldTo,float tfWorldFrom,float tfWorldTo ) ;

    virtual void    SetWeightingVolumeFromRef(float f)                  {m_fWeightingVolumeFromRef=f;};
    virtual float   GetWeightingVolumeFromRef()                         {return m_fWeightingVolumeFromRef;};
    virtual void    SetVolumeFromRefOrigin( float f )                   {m_fVolumeFromRefOrigin = f;};
    virtual float   GetVolumeFromRefOrigin()                            {return m_fVolumeFromRefOrigin;};
    virtual void    SetStandardDeviationRef( float f )                      {m_fStandardDeviation = f;};
    virtual float   GetStandardDeviationRef( )                              {return m_fStandardDeviation;};
    virtual void    SetMaskImageForRefVolume( zxhImageData* p )         {m_pMaskImageForRefVolume=p;};
    virtual zxhImageData*   GetMaskImageForRefVolume()                  {return m_pMaskImageForRefVolume;};
    /* compute the volume change based on Jacobian */
    virtual inline float    GetWeightedLocalVolumeChanges(float fVolumeChanges)
    {
        float  gau = exp(zxh::abs(log(fVolumeChanges)))-1 ;
        if( gau < m_fStandardDeviationTest )
            return 0 ;
        if( gau < m_fStandardDeviationTest*2 )
            return -gau/m_fStandardDeviationTest ;
        return -gau*gau/(m_fStandardDeviationTest*m_fStandardDeviationTest);
    }
    virtual float GetWeightedVolumeChangesFromTest( float &fNumVolumeCounted,
                    zxhTransformBase * pTrans,zxhTransformBase * pRegriddingTrans,
                    zxhImageData * pMaskTest,
                    float xfWorldFrom,float xfWorldTo,float yfWorldFrom,float yfWorldTo,
                    float zfWorldFrom,float zfWorldTo,float tfWorldFrom,float tfWorldTo ) ;
    virtual void    SetWeightingVolumeFromTest(float f)                 {m_fWeightingVolumeFromTest=f;};
    virtual float   GetWeightingVolumeFromTest()                        {return m_fWeightingVolumeFromTest;};
    virtual void    SetStandardDeviationTest(float f)                   {m_fStandardDeviationTest=f;};
    virtual float   GetStandardDeviationTest()                          {return m_fStandardDeviationTest;};
    virtual void    SetRegriddingdTransform(zxhTransformBase*p)         {m_pRegriddingdTransform =p;};
    virtual zxhTransformBase* GetRegriddingdTransform()                 {return m_pRegriddingdTransform;};
    virtual void    SetMaskImageForTestVolume( zxhImageData*p )         {m_pMaskImageForTestVolume=p;};
    virtual zxhImageData* GetMaskImageForTestVolume()                   {return m_pMaskImageForTestVolume;};
 
    virtual int ComputeConstanceForGradient() ;
 
protected:
    float               m_fWeightingVolumeFromRef ;
    float               m_fStandardDeviation ;
    float               m_fVolumeFromRefOrigin ;
    float               m_fVolumeFromRefCurrentTransform ;
    zxhImageData*       m_pMaskImageForRefVolume ;
    float               m_fWeightingVolumeFromTest ;
    float               m_fStandardDeviationTest ;
    zxhTransformBase    *m_pRegriddingdTransform ;
    float               m_fVolumeFromTestCurrentTransform ;
    float               m_fNumVolumeFromTestCurrentTransform ;
    zxhImageData*       m_pMaskImageForTestVolume ;
};

#endif