zxhTransformIterateInverse.h

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

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

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

#ifndef zxhTransformIterateInverse_H
#define zxhTransformIterateInverse_H

#include "zxhTransformFields.h"
#include "zxhImageData.h"
#include <string.h>
#include <stdio.h>

#ifndef  m_staticMinimalSpace
#define m_staticMinimalSpace 0.01f
#endif
#ifndef  m_staticMinimalSampling
#define m_staticMinimalSampling 1 // it's so weird that 2 works worse than 1
#endif

class zxhTransformIterateInverse : public zxhTransformFields
{
public:
    zxhTransformIterateInverse();
    virtual ~zxhTransformIterateInverse();

    virtual void SetTransform( zxhTransformBase*p )         {m_pTransform=p;} ;
    virtual void NewInverseTransformImages( int dim, const int*size, const float*spacing, const zxhImageInfo*pimageinfo )
    {   NewTransformImages( dim, size, spacing, pimageinfo ) ; } ;
    virtual void SetRoi( int dim, int *from, int* to )
    {
        this->SetDimension( dim );
        for( int id=0; id<dim; ++id )
            m_aiRoi[0][id]=from[id], m_aiRoi[1][id]=to[id] ;
    } ;
    //virtual bool ComputeInverseTransform( float fPercentage=0.2 ) ;
    virtual bool ComputeInverseByDistanceInterpolate();
    virtual bool Evaluate()
    {   return ComputeInverseByDistanceInterpolate() ; }
    virtual void    SetJacWeighting( float f )              { m_fJacWeighting=f; };
    virtual float   GetJacWeighting()                       { return m_fJacWeighting;};
    virtual void    TransformWorldToWorld(const float fVectorFromWorld[ImageDimensionMax],float fVectorToWorld[ImageDimensionMax]);

protected:
    /*std::string       m_strTransformFiles[ImageDimensionMax]; from fields
    zxhImageGiplT<float>  m_pimgTransformFields[ImageDimensionMax];
    zxhImageModelingLinearT<float,float> m_pmodelTransformFields[ImageDimensionMax];*/
    zxhTransformBase    *m_pTransform;
    int     m_aiRoi[2][ImageDimensionMax] ;
    float   m_fIterateLength ; // 0:l:1
    float   m_fExponent ;
    int     m_iFillRange[2] ;
    float   m_fJacWeighting ;
    virtual bool    ForwardTransformToRefGrid( int* roiFrom, int* roiTo,
                            zxhImageDataT<float>* imgFindInverseDis,
                            zxhImageDataT<float>* imgFindInverseCoX,
                            zxhImageDataT<float>* imgFindInverseCoY,
                            zxhImageDataT<float>* imgFindInverseCoZ ) ;
    virtual int FillInFindInverse( zxhImageDataT<float>* imgFindInverseDis,
                                                zxhImageDataT<float>* imgFindInverseCoX,
                                                zxhImageDataT<float>* imgFindInverseCoY,
                                                zxhImageDataT<float>* imgFindInverseCoZ );
    virtual void    DistanceWeightInterpolateByNeighbours( zxhImageDataT<float>* imgFindInverseDis,
                                                zxhImageDataT<float>* imgFindInverseCoX,
                                                zxhImageDataT<float>* imgFindInverseCoY,
                                                zxhImageDataT<float>* imgFindInverseCoZ );
    virtual void ComputeJacxyzForwardVoxel( float*Jacxyz, zxhTransformBase* pTransform, float *phyco, float *phycoTo, float*spacing) ;
    virtual void MapToGrid8Neighbour( float* WorldFrom, float*WorldTo, float* gridcoTo, int i, int j, int k, zxhImageDataT<float>*pImgTemp,
                                zxhImageDataT<float>* imgFindInverseDis,
                                zxhImageDataT<float>* imgFindInverseCoX,
                                zxhImageDataT<float>* imgFindInverseCoY,
                                zxhImageDataT<float>* imgFindInverseCoZ ) ;
    virtual  void ComputeSamplingSpacing(float * JacSpacing, float * Jacxyz, float * spacing)
    {ComputeSamplingSpacingByMaximalPoints(JacSpacing, Jacxyz, spacing);}
    virtual void    ComputeSamplingSpacingByProduct(float * JacSpacing, float * Jacxyz, float * spacing); 
    virtual void    ComputeSamplingSpacingByMaximalPoints(float * JacSpacing, float * Jacxyz, float * spacing);
    virtual void    DistanceWeightInterpolationOct( float afInterpolateResult[], float * afInterpolateSource, float *afDisSquared );
};
#endif //