zxhMetricNV.h

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

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

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

#ifndef zxhMetricNV_H
#define zxhMetricNV_H

#include "zxhTransformBase.h"
#include "zxhTransformFFDBase.h"
#include "zxhOptimizerBase.h"
#include "zxhImageModelingBase.h"
#include "zxhMetricBase.h"
#include "zxhMetricFFDBase.h"


class zxhMetricNV :public zxhMetricBase, public zxhMetricFFDBase  
{
public:
    zxhMetricNV() ;
    virtual ~zxhMetricNV() ;

    virtual std::string GetMetricType() {return "_NV_"+zxhMetricFFDBase::GetMetricType(); } ;

    virtual zxhMetricBase* Clone(zxhMetricBase*&pRet) ;
    virtual std::string GetPrintString() {return "";};
    virtual bool        SetMetricFromStream(std::ifstream & ifs){return false;};

    virtual int GetValue(zxhlfloat& fValue) {return -1;};
    virtual bool    SetImage(zxhImageData*pImageTest,zxhImageData*pImageRef)
    {
        bool b = zxhMetricBase::SetImage( pImageTest, pImageRef ) ;
        return (b && ComputeSigmaFromImageIntensity()) ;
    };


/***  compute for FFD registration or for MetricFFDBase interface ***/
    ;
    virtual int GetValueByFFDGrid(zxhlfloat&fValue,int aiCtrPnt[ImageDimensionMax]) {return -1;};

    virtual int GetValueFromRegion( zxhlfloat&fValue,
                        float xfWorldFrom,float xfWorldTo,float yfWorldFrom,float yfWorldTo,
                        float zfWorldFrom,float zfWorldTo,float tfWorldFrom,float tfWorldTo) {return -1 ;} ;

    virtual int ComputeConstanceForFFDGradient() {return -1 ;} ;

    virtual int GetDiffByFFDGrid( float * afPD, // output partial differentiation
                                  zxhTransformFFDBase * pFFDGrid,
                                  int * aiCtrPnt,
                                  zxhTransformFFDBase * pDifferential ) {return -1;};
    virtual int GetDiffByFFDGridOnFFDPhysicalVector( float * afPD, // output partial differentiation
                                          zxhTransformFFDBase * pFFDGrid,
                                          int * aiCtrPnt,
                                          zxhTransformFFDBase * pDifferential,
                                          float * vector)
    {std::cerr<<"error: zxhMetricNV::GetDiffByFFDGridOnFFDPhysicalVector NOT implemented yet\n";
     return zxhMetricFFDBase::GetDiffByFFDGridOnFFDPhysicalVector(afPD, pFFDGrid, aiCtrPnt, pDifferential, vector); } ;

    virtual void    SetSingleModality( bool b ) { m_bSingleModalityRegistration=b; } ;
    virtual bool    GetSingleModality()         {return m_bSingleModalityRegistration ; };

     //
    zxhImageDataT<float>*   testGetLEMvoxelForceImage() { return &m_imgVoxelForces[0];};

    void testSetNoiseLevel( float f )   {m_fStaticNoiseLevel=f;};
protected:
    virtual void    SetFFDMetricBase()  {m_pMetricBase=this;};
    virtual void    InverseTransformIntensityGradientVector(float fVectorRef[ImageDimensionMax],float fInverseVectorTest[ImageDimensionMax],float* fWorldTest )
    {
        if( this->m_pForwardComposedTransform == 0 )
            this->m_pTransform->InverseTransformIntensityGradientVector( fVectorRef, fInverseVectorTest, fWorldTest ) ;
        else
        {
            float fWorldMid[] = {fWorldTest[0],fWorldTest[1],fWorldTest[2],fWorldTest[3]} ;
            this->m_pForwardComposedTransform->TransformWorldToWorld( fWorldTest, fWorldMid ) ;
            this->m_pTransform->InverseTransformIntensityGradientVector( fVectorRef, fInverseVectorTest, fWorldMid ) ;
            this->m_pForwardComposedTransform->InverseTransformIntensityGradientVector( fInverseVectorTest, fInverseVectorTest, fWorldTest );
        }
    }
    virtual void    TransformIntensityGradientVectorTo(float fVectorFrom[ImageDimensionMax],float fVectorTo[ImageDimensionMax],float* fWorldFrom )
    {
        this->m_pTransform->TransformIntensityGradientVectorTo( fVectorFrom, fVectorTo, fWorldFrom ) ;
        if( this->m_pForwardComposedTransform !=0 )
        {
            float fWorldMid[] = {fWorldFrom[0],fWorldFrom[1],fWorldFrom[2],fWorldFrom[3]} ;
            this->m_pTransform->TransformWorldToWorld( fWorldFrom, fWorldMid ) ;
            this->m_pForwardComposedTransform->TransformIntensityGradientVectorTo( fVectorTo, fVectorTo, fWorldMid ) ;
        }
    }
    virtual bool    ComputeSigmaFromImageIntensity() {return false;};
    virtual float ComputeConsineThetaAndConfidenceFunction( float gv1[], float gv2[] ) {return -1;};

    zxhImageDataT<float>        m_imgVoxelForces[ImageDimensionMax] ;
    float                       m_fSquareSigma[2];

    float                       m_fStaticNoiseLevel ;


    bool                        m_bSingleModalityRegistration ;
}  ;

//const float zxhMetricNV::m_fStaticNoiseLevel = 0.02 ; 

typedef zxhMetricNV zxhMetricLEM ;
typedef zxhMetricNV zxhMetricLEMFFD ;
typedef zxhMetricNV zxhMetricCLEM ;
typedef zxhMetricNV zxhMetricCLEMFFD ;
typedef zxhMetricNV zxhMetricNVFFD ;
#endif //