zxhValidation.h

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

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

=========================================================================*/
#ifndef zxhValidation_h
#define zxhValidation_h

#include <iostream>
#include <fstream>
#include <math.h>

#include "zxhDllExport.h"
#include "zxh.h"
#include "zxhImageData.h"
#include "zxhImageGipl.h"
#include "zxhImageModelingLinear.h"
#include "zxhTransformAffine.h"
#include "zxhTransformFFD.h"
#include "zxhImageModelingBase.h"

#ifndef max_of_distance
#define max_of_distance 100  // voxels
#endif
#ifndef start_of_distance
#define start_of_distance 2 //  radius of searchingvolume
#endif
#ifndef max_of_graylevel_short
#define max_of_graylevel_short 0x7fff
#endif
#ifndef ZXH_GrayLevelOfSurface
#define ZXH_GrayLevelOfSurface 1
#endif
namespace zxh{

ZXH_DLL_EXPORT void Seg2Binf(zxhImageData* seg,zxhImageDataT<float> *bin);
ZXH_DLL_EXPORT void Binf2Sur(zxhImageDataT<float>*bin, zxhImageData*sur);
ZXH_DLL_EXPORT void TransformImageInverseByDeformField(zxhImageDataT<float>*pInvImg,zxhImageModelingLinearT<float,float>*pRef,
                                                       zxhImageDataT<float>*pDef[ImageDimensionMax]);
ZXH_DLL_EXPORT std::string ComputeRealError(zxhImageData*pTest, zxhTransformBase* pGold, zxhTransformBase* pTrans,
                             int iSaveMedial,std::string strSavePathName,zxhImageData*pMask=0);
//ZXH_DLL_EXPORT std::string ComputeRealError(zxhImageData*pTest,zxhImageDataT<float>*pGold[ImageDimensionMax],
//                                          zxhImageDataT<float>*pDeform[ImageDimensionMax],
//                           int iSaveMedial,std::string strSavePathName,zxhImageData*pMask=0);
ZXH_DLL_EXPORT std::string ComputeInconsistency(zxhImageData*pTest,zxhTransformBase*pTest2Ref,zxhTransformBase*pRef2Test,
                                 int iSaveMedial,std::string strSavePathName,zxhImageData*pMask=0);
ZXH_DLL_EXPORT std::string ComputeDeformField(zxhImageData*pTest,zxhImageDataT<float>*pDeformMag,zxhImageData*pMask);
ZXH_DLL_EXPORT std::string ComputeDeformField(zxhImageData*pTest,zxhTransformBase*pTest2Ref,
                                 int iSaveMedial,std::string strSavePathName,zxhImageData*pMask=0);
ZXH_DLL_EXPORT std::string ComputeDeformField(zxhImageData*pTest,zxhImageDataT<float>*pDeform[ImageDimensionMax],
                                 int iSaveMedial,std::string strSavePathName,zxhImageData*pMask=0);

ZXH_DLL_EXPORT bool ComputeSurfaceDistance(zxhImageData*pSurTest,zxhImageData*pSurRef,zxhTransformBase*pTrans,
        zxhlfloat &fsum, zxhlfloat &fsqsum, zxhlfloat &fmax, zxhlfloat &fmin, zxhlfloat &nTestSurface,
        zxhlfloat errorrange[6], zxhImageDataT<float> * pdis_mag ) ;
ZXH_DLL_EXPORT std::string ComputeSurfaceDistance(zxhImageData*pSurTest,zxhImageData*pSurRef,
        zxhTransformBase*pTrans,int iSaveMedial,std::string strSaveFileName);

ZXH_DLL_EXPORT std::string ComputeSurfaceDistanceClostPoint(zxhImageData*pSurTest,zxhImageData*pSurRef,
        zxhTransformBase*pTrans,int iSaveMedial,std::string strSaveFileName) ;
ZXH_DLL_EXPORT std::string ComputeSurfaceDistanceSwap(zxhImageData* apSurTest[2],zxhImageData* apSurRef[2] );
ZXH_DLL_EXPORT float ComputeOverlap(zxhImageDataT<float>*pBinTest,zxhImageDataT<float>*pBinRef,zxhTransformBase*pTrans);
ZXH_DLL_EXPORT float ComputeOverlap(zxhImageDataT<float>*pBinTest,zxhImageDataT<float>*pBinRef,zxhImageDataT<float>*pDeform[ImageDimensionMax]);

zxhlfloat DisPnt2Triangle(zxhlfloat pnt[3],zxhlfloat pTr1[3],zxhlfloat pTr2[3],zxhlfloat pTr3[3]) ;
float DisPnt2Triangle(float pnt[3],float pTr1[3],float pTr2[3],float pTr3[3]) ;

zxhlfloat VOPDistance(int dim,const zxhlfloat* A, const zxhlfloat* B);
void VOPCrossProduct( const zxhlfloat* A, const zxhlfloat* B, zxhlfloat* AxB );
zxhlfloat VOPDotProduct(int dim,const zxhlfloat* A,const zxhlfloat* B);
zxhlfloat VOPVectorLength(int dim,const zxhlfloat* A);

template <class imagevoxel>
void SelectRoi(zxhImageDataT<imagevoxel>*pImg,const int pFrom[3],const int pTo[3])
{
    for(int it=0;it<pImg->GetImageSize()[3];++it)
    for(int ix=0;ix<pImg->GetImageSize()[0];++ix)
    for(int iy=0;iy<pImg->GetImageSize()[1];++iy)
    for(int iz=0;iz<pImg->GetImageSize()[2];++iz)
    {
        if(!(ix>=pFrom[0]&&ix<=pTo[0]&&
            iy>=pFrom[1]&&iy<=pTo[1]&&
            iz>=pFrom[2]&&iz<=pTo[2]))
            pImg->SetPixelByGreyscale(ix,iy,iz,it,0);
    }
};

struct surface_point
{
    float   fx;
    float   fy;
    float   fz;
    float   ft;
    float           fDistance;
    int             nNumber;
    surface_point   *       pNext;
};

template<class type>
void NewMedialImage(zxhImageDataT<type>*pTem,zxhImageDataT<float>*pDim,zxhImageDataT<float>*pMag)
{
    for(int idim=0;idim<pTem->GetDimension();++idim)
    {
        pDim[idim].NewImage(pTem->GetDimension(),pTem->GetImageSize(),pTem->GetImageSpacing(),pTem->GetImageInfo() );
    }
    pMag->NewImage(pTem->GetDimension(),pTem->GetImageSize(),pTem->GetImageSpacing(),pTem->GetImageInfo() );
}



}//endof namespace zxh

#endif //zxhValidation_h