zxhRegistrationStruct.h

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

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

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

#ifndef zxhRegistrationStruct_h
#define zxhRegistrationStruct_h

#include <string>
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <stdlib.h>
#include "zxh.h"
#include "zxhImageData.h"
#include "zxhTransformBase.h"
#include "zxhMetricBase.h"
#include "zxhImageModelingLinear.h"
#include "zxhImageModelingBase.h"
#include "zxhImageProcessPhase.h"

#ifndef ZXH_LocalAffinePreSetGDImageDilation
#define ZXH_LocalAffinePreSetGDImageDilation -1
#endif 

#ifndef ZXHOTHERIMAGEMAX
#define ZXHOTHERIMAGEMAX 10
#endif

struct zxhStructSEMI
{
    float               m_afMMILambda[ZXH_MaxRegistrations] ;
    float               m_fMMIsigma ;
    // side length/diameter (mm) of cubic local region/sphere region
    float               m_fSemiLocalRegionSize[ZXH_MaxRegistrations] ;
    enum zxh::TypeSEMIKernelFunction m_iSEMIKernelType ;
};
#ifndef ZXHMMISAMPLETIMES
#define ZXHMMISAMPLETIMES 1.0
#endif

struct zxhStructMultiImage
{
    int     NumImage ;
    zxhImageData    ImageTest[ZXHOTHERIMAGEMAX];
    zxhImageData    ImageRef[ZXHOTHERIMAGEMAX];
    float           WeightMetric[ZXHOTHERIMAGEMAX] ;
};
struct zxhStructPhaseReg
{ 
    bool                    m_bPhaseRegistration ;
    float                   m_fPhaseWeightings[3]; //zxhlfloat  [0]wi=1.0/3.0, [1]wf=1.0/3.0, [2]wo=1.0/3.0 ;
    // pointer to the phase processer in MetricPhase. Use them to reset the phase update in metric
    zxhImageProcessPhaseT<short,float>* m_pPhaseProcessTest ;
    zxhImageProcessPhaseT<short,float>* m_pPhaseProcessRef ;
    zxhImageData            m_CopiesPhaseOrientTest[3];
    zxhImageData            m_CopiesPhaseOrientRef[3] ;
    zxhImageDataT<float>    m_PhaseOrientCurrTest[3];
    zxhImageDataT<float>    m_PhaseOrientCurrRef[3] ;
    zxhImageModelingBaseT<float,float>  m_PhaseOrientModelTest[3] ;
    zxhImageModelingBaseT<float,float>  m_PhaseOrientModelRef[3] ;
    zxhImageModelingBaseT<float,float>  *m_apPhaseOrientModelTest[3] ;
    zxhImageModelingBaseT<float,float>  *m_apPhaseOrientModelRef[3] ;
};
struct zxhStructFFDReg
{
    
    zxhImageData*       m_CopyFFDMaskTestOrig ;
    zxhImageData*       m_CopyFFDMaskRefOrig ;
    zxhImageData*       m_CopyRegionForComputeDirectionFFDsNVRefOrig ;

    float               m_fFFDSpace[ZXH_MaxRegistrations*ImageDimensionMax];
    bool                m_bFFDInactiveBorders ;
    bool                m_abFFDsUsingSubVolume[ZXH_MaxRegistrations];
    float               m_afFFDsBendingEnergyWeight[ZXH_MaxRegistrations];

    zxhImageData        m_FFDMaskTestCurr ;
    float               m_fFFDMaskTestDilateLength ;

    zxhImageData        m_FFDMaskRefCurr ;
    float               m_afFFDMaskRefDilateLength[ZXH_MaxRegistrations] ;
    zxhImageData        m_RegionForComputeDirectionFFDsNVRef ;
    zxhImageDataF       m_DirectionFFDsNVRefCurr ;
    zxhImageModelingLinearT<float,float> m_FFDDirectionModelNVRef;
    bool                m_bFFDShaped ;
    float               m_fFFDRegriddingPortion ;
    
};
struct zxhStructLocalAffineReg
{
    // this copies doNOT need to be new/delete
    zxhImageData        m_CopiesLocalAffineRegions[ZXH_LocalAffineMaxNumber] ;
    zxhImageData        m_CopiesComputeLocalGradientRegionsMask[ZXH_LocalAffineMaxNumber];

    zxhTransformBase    *m_pLocalAffineForwardComposedMatrix[ZXH_LocalAffineMaxNumber];
    int                 m_iNumLocalAffines ;
    int                 m_iLocalAffineTransType[ZXH_LocalAffineMaxNumber] ;
    zxhImageData *      m_aLocalAffineRegions ;
    float               m_fMinDistanceBetweenRegions ;
    zxhImageData        m_aComputeLocalGradientRegions[ZXH_LocalAffineMaxNumber];
    zxhImageData        m_aComputeLocalGradientRegionsMask[ZXH_LocalAffineMaxNumber]; 
    float               m_fDilateLocalGradientRegions[ZXH_LocalAffineMaxNumber]; //mm -1 means pre-set mask image(s)
    float               m_fThresholdMaxLocalDisplace ;
    float               m_fWorldFacetsFromTo[2][ImageDimensionMax] ;
    //float             m_fOverlapRegionDilateLength ;
    //float             m_fEstimateLocalRegionSize[ZXH_LocalAffineMaxNumber] ;
    //int               m_iLocalAffinePreOptimiseGlobal ;
    //int               m_iLocallyOptimiseSteps ;
    int                 m_iLocallyAffineOptimiseType ;// 0 accessory optimise, 1 globally optimise, -1 region based optimse
    float               m_fLocalAffineSearchLength ;
    float               m_fLocalAffineDifferentialLength ;
    float               m_fLocalAffineConcatenateThreshold ;
    // sampling for checking jacobian value, default is same as m_fWorldSamplingDistance
    float               m_fLocalAffineJacobianSampleWorld[ImageDimensionMax] ;
    zxhImageData        m_LocalAffineRegriddingMaskImage;
    zxhTransformBase*   m_pLocalAffineGlobalBfRegridding ;
    float               m_fLocalAffineDiffk ;
    float               m_fLocalAffineDifft[ImageDimensionMax] ;
    float               m_fLocalAffineDiffs[ImageDimensionMax] ;
    float               m_fLocalAffineDiffr[ImageDimensionMax] ;
};
class zxhRegistrationStruct
{
public:
    int                 m_iInitRegInfoStatus ;

    zxhTransformBase*   m_CopyInitialTransform ;
    // copies test/target image space info
    zxhImageData*       m_CopyImageTestOrig ;
    zxhImageData*       m_CopyMaskTestOrig ;
    zxhImageData*       m_CopyRegionForComputeDirectionFFDsNVTestOrig ;
    zxhImageData        m_imgWeightShort100TestOrig ;
    
    // copies reference/source image space info
    zxhImageData*       m_CopyImageRefOrig ;
    zxhImageData*       m_CopyImageRefGaussian ;
    zxhImageData*       m_CopyMaskRefOrig ;;
    zxhImageData*       m_CopyMaskImageForRefVolume ;
    zxhImageData        m_imgWeightShort100RefOrig ;

    // currently also served as forwardcomposed concatenation transformation
    // transformation: m_pConcatenatedFowardCompose X m_pTransformCurr X m_pConcatenatedTransformsByRegridding
    zxhTransformBase*   m_pConcatenatedTransformsByRegridding ;
    int                 m_iStatusForwardConcatenation ; // -1 not, 0 not set, 1 yes
    zxhTransformBase*   m_pConcatenatedFowardCompose ;
    //
    bool                m_bConstraintCost ;

    zxhStructSEMI       m_StructSEMI ;
    zxhStructPhaseReg   m_StructPhaseReg;

    zxhMetricBase*      m_pMetric ;
    zxhTransformBase *  m_pTransformCurr ;
    zxhTransformBase *  m_pDifferentialCurr ;
    zxhTransformBase *  m_pInfluenceCurr ;

    zxhImageData        m_imgTestCurr ; // been gaussian according to m_fWorldSamplingDistance
    zxhImageData        m_imgMaskTestCurr ;
    float               m_fMaskTestDilateLength ;

    zxhImageData        m_imgRefCurr ;
    zxhImageData        m_imgMaskRefCurr ;
    float               m_fMaskRefDilateLength ;

    struct zxhStructMultiImage m_StructMultiImage ;

    zxhImageDataT<float> m_imgWeightFloatTest ;
    zxhImageDataT<float> m_imgWeightFloatRef ;
    zxhImageModelingLinearT<float,float> m_modelWeightTest ;
    zxhImageModelingLinearT<float,float> m_modelWeightRef ;

    float               m_afGaussianSmoothTestImage[ZXH_MaxRegistrations];
    float               m_afGaussianSmoothRefImage[ZXH_MaxRegistrations];

    int                 m_iRegistrationDimension;
    std::string         m_sLoadTransformFile ;
    int                 m_iRoiCooFromTo[2][ImageDimensionMax] ;
    std::string         m_sOuputString ;
    bool                m_bComputeInverse ;
    int                 m_iNumRegistrations ;
    int                 m_iCurrRegistration ;
    float               m_fWorldSamplingDistance[ImageDimensionMax*ZXH_MaxRegistrations];

    //metric penalty term mask
    float               m_fWeightingVolumeFromRef ;
    zxhImageData        m_MaskImageForRefVolume ;
    float               m_fVolumeFromRefStandardDeviation ;

    float               m_fWeightingVolumeFromTest ;
    zxhImageData        m_MaskImageForTestVolume ;
    float               m_fVolumeFromTestStandardDeviation ;


    // rigid=0,rig+scale=1,aff=2, ffd=3, fbs=4, skew=5, grid=6 ; LocalAffines=10
    enum zxh::ZXH_TransformType m_iTransType ;
    // for affine transformation
    //float             m_fEstimateSubjectSize ;
    int                 m_iAffinePreSettingType ;
    float               m_fAffinePreScaling[ImageDimensionMax] ;
    float               m_fAffinePreRotate[ImageDimensionMax] ;
    float               m_fAffinePreTranslate[ImageDimensionMax] ;
    float               m_fAffineDiffk ;
    float               m_fAffineDifft[ImageDimensionMax]  ;
    float               m_fAffineDiffs[ImageDimensionMax]  ;
    float               m_fAffineDiffr[ImageDimensionMax]  ;
    // local affines
    struct zxhStructLocalAffineReg  m_StructLocalAffineReg ;

    // FFDs
    struct zxhStructFFDReg      m_StructFFDReg ;
    //
    bool                m_bDiffeomorphism ;
    float               m_fConcatenationSampling[ImageDimensionMax]; 
    float               m_afRegularRate[ZXH_MaxRegistrations] ;
    float               m_fSearchLength[ZXH_MaxRegistrations] ;
    int                 m_iLineSearch[ZXH_MaxRegistrations] ; // 0:un-set, -1: no, 1: yes;
    int                 m_iOptimiseMaxSteps[ZXH_MaxRegistrations] ;
        // -1 unset [no], 0 set no, 1 set yes 
    int                 m_aiHeartReg[ZXH_MaxRegistrations] ; 
    //float             m_fDiff[ZXH_MaxRegistrations]   ;//1 mm

public: //methods
    float * GetRegriddingSamplingWorld()
    {
        if( this->m_fConcatenationSampling[0]!=0 &&this->m_fConcatenationSampling[1]!=0
            && this->m_fConcatenationSampling[2]!=0 )
            return & (this->m_fConcatenationSampling[0]) ;
 
        this->m_fConcatenationSampling[0] = 2 ;
        this->m_fConcatenationSampling[1] = 2 ;
        this->m_fConcatenationSampling[2] = 2 ;
        return & (this->m_fConcatenationSampling[0]) ;
    }
    float * GetForwardConcatenationSamplingWorld()
    {return this->GetRegriddingSamplingWorld();}

    void FreeRegistrationStruct() ;
    void InitRegistrationStruct() ;

    // only used in zxhOptimizerGradientLocalMatrix::ConcatenateTransformsNUpdate
    // init local region/ overlap correction 
    // but nothing done to m_aComputeLocalGradientRegionsMask (this step do in InitLocallyAffineRegionsFromCopies)
    int InitLocallyMatrixRegionsWithinConcatenationFromCopies( ) ;


/*  * 1. setting m_aLocalAffineRegions 
    * 2. check no overlap between m_aLocalAffineRegions (return number of overlap voxels)
    * 3. m_aComputeLocalGradientRegions using m_fDilateLocalGradientRegions
 *  */
    int  InitLocallyAffineRegionsFromCopies();
    int  InitLocallyAffineNoneOverlap();
    void ReComputeLocalGradientRegions(); 
    
    void BackwardTransformRefCopiesByConcatenatedTransforms();

    void BackwardTransformRefCopiesByConcatenatedTransformsForPhase();
    
    void ComposeForwardRegridingToOneVariable();

    void RegForwardTransformNScaleGaussianForMultiResolution(); 
 
    bool InitWeightImages( char type, zxhTransformBase* pTrans=0) ;
};
 

#endif