FMEwork/Release/Sources/Shared/DTICalculator/IDTICalculator.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------

#ifndef __IDTICalculator__H_
#define __IDTICalculator__H_

#include "mlMacros.h"


#include <MLMiscMath.h>



// DLL export macro definition
#ifdef DTICCALCULATOR_EXPORTS
  // Use the MLCSOLISTWRAPPERS_EXPORT macro to export classes and functions
  #define DTICCALCULATOR_EXPORT ML_LIBRARY_EXPORT_ATTRIBUTE
#else
  // If included by external modules, exported symbols are declared as import symbols
  #define DTICCALCULATOR_EXPORT ML_LIBRARY_IMPORT_ATTRIBUTE
#endif

const double DIFFUSION_CONST = 1000.0;


class ML_UNIX_ONLY_EXPORT(DTICCALCULATOR_EXPORT) IDTICalculator
{

public:

    virtual ~IDTICalculator(){};

    typedef MLMISCMATH_NAMESPACE::Math_Error_Type Error_Type;

    enum ErrorCodes{
        noErr                    = MLMISCMATH_NAMESPACE::noErr,

        matrixInvertErr          = MLMISCMATH_NAMESPACE::matrixInvertErr,
        matrixDiagErr            = MLMISCMATH_NAMESPACE::matrixDiagErr,
        negEVErr                 = MLMISCMATH_NAMESPACE::negEVErr,
    };


    virtual MLuint32 getDimension() const=0;

    virtual Error_Type setGradients(const double **aGradients, const MLuint32 lNrOfGradients)=0;

    virtual double getTensorError(const double *pLNNorm, const MLuint32 lNrOfGradients)=0;

    virtual MLuint32 getNrOfGradients() const=0;

    template<typename DATATYPE>
    static void calcLNNorm(double *pLNNorm, const DATATYPE* const *pInPtr, const MLuint32 lNrDWImages,
                           const double *bValueArray = NULL, const int bValue=1000)
    {
        const double ln_2 = 0.69314718055994530941723212145818;
        DATATYPE s0 = *(pInPtr[0]);

        for (MLuint32 i=1;i<lNrDWImages;i++)
        {
            DATATYPE si = *(pInPtr[i]);

            if ( si >= s0 )
            {
                pLNNorm[i-1] = 0.0;
            }
            else if (s0 != 0 && si == 0)
            {
                pLNNorm[i-1] = ((sizeof(MLuint16)<<3)+1)*ln_2; // different data types should always lead to same results, thus, MLuint16 is used for all of them!
            }
            else
            {
                if (bValueArray==NULL)
                {
                    pLNNorm[i-1]  = log(static_cast<double>(si)/static_cast<double>(s0))*(-DIFFUSION_CONST/static_cast<double>(bValue));
                }
                else
                {
                   // note si and s0 are exchanged
                    pLNNorm[i-1]  = log(static_cast<double>(si)/static_cast<double>(s0))*(-DIFFUSION_CONST/bValueArray[i-1]);
                }
            }
        }

    }


    virtual const double* calcDiffusionTensor(const double *pLNNorm) = 0;

    virtual Error_Type eigenAnaly()                                  = 0;
    virtual Error_Type eigenAnaly(double regularizationParam)        = 0;

    virtual const double* getEigenvalues()                     const = 0;

    virtual const double* getEigenvectors()                    const = 0;


    static double normalizeDiffusionStrength(double dDiffStrength,
                                             double dDiffusionNorm,
                                             double dDiffThreshold)
    {
        if ( dDiffusionNorm > 0.0)
        {
            dDiffStrength /= (dDiffusionNorm);
            if (dDiffStrength > 1.0)
            {
                dDiffStrength = 1.0;
            }
            else if (dDiffStrength < dDiffThreshold)
            {
                 dDiffStrength = 0.0;
            }
        }
        else
        {
            dDiffStrength = 1.0;
        }
        return dDiffStrength;
    }



    virtual void DeleteDTICalculator ()=0;

};


class QuantificationFunction;

#ifdef __cplusplus
extern "C" {
#endif

    ML_UNIX_ONLY_EXPORT(DTICCALCULATOR_EXPORT) IDTICalculator* NewDTICalculator(MLuint32 dim);

    //QuantificationFunction* NewQuantificationFunction(IDTICalculator::Diffiusion_Mode eMode);


#ifdef __cplusplus
}
#endif

#endif // __IDTICalculator__H_