mitkTransform.h

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

  Program:   3DMed
  Date:      $Date: 2014-02-25 18:30:00 +0800 $
  Version:   $Version: 4.6.0 $
  Copyright: MIPG, Institute of Automation, Chinese Academy of Sciences

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


#ifndef __mitkTransform_h
#define __mitkTransform_h

#include "mitkProcessObject.h"
#include "mitkVolume.h"
#include "mitkList.h"
#include "mitkGlobalRegistrationFramework.h"
#include "mitkRCPtr.h"

#include "mitkOoCGlobalSettings.h"

#define INVALID_COORDINATES 10e4

// A LIST OF TRANSFORM METHODS IMPLEMENTED IN MITK                      RELATED CLASS
//-------------------------------------------------------+------------------------------------------

#define MITK_TRANSFORM_SCALE                        0               // mitkScaleTransform
#define MITK_TRANSFORM_SCALE_LOGARITHMIC            1               // mitkScaleTransform
#define MITK_TRANSFORM_ROTATION                     2               //   (scheduled)
#define MITK_TRANSFORM_TRANSLATION                  3               // mitkTranslationTransform
#define MITK_TRANSFORM_RIGID                        4               // mitkRigidTransform
#define MITK_TRANSFORM_RIGID_CENTERED               5               //   (scheduled)
#define MITK_TRANSFORM_SIMILARITY                   6               // mitkSimilarityTransform
#define MITK_TRANSFORM_SIMILARITY_CENTERED          7               //   (scheduled)
#define MITK_TRANSFORM_AFFINE                       8               // mitkAffineTransform
#define MITK_TRANSFORM_AFFINE_CENTERED              9               //   (scheduled)
#define MITK_TRANSFORM_VERSOR_RIGID_3D              10              // mitkVersorRigid3DTransform
#define MITK_TRANSFORM_VERSOR_SIMILARITY_3D         11              // mitkVersorSimilarity3DTransform
#define MITK_TRANSFORM_HOMOGRAPHY                   12              //   (scheduled)
#define MITK_TRANSFORM_PROJECTIVE                   13              //   (scheduled)
#define MITK_TRANSFORM_QUADRATIC                    14              //   (scheduled)
#define MITK_TRANSFORM_POLYNOMIAL                   15              //   (scheduled)
#define MITK_TRANSFORM_THINPLATESPLINE_R            21              // mitkThinPlateSplineTransform
#define MITK_TRANSFORM_THINPLATESPLINE_R2LOGR       22              // mitkThinPlateSplineTransform
#define MITK_TRANSFORM_ELASTICBODYSPLINE            23              //   (scheduled)
#define MITK_TRANSFORM_VOLUMESPLINE                 24              //   (scheduled)
#define MITK_TRANSFORM_FREEFORM_BSPLINE             31              // mitkBSplineFreeFormTransform
#define MITK_TRANSFORM_FREEFORM_NURBS               32              //   (scheduled)

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


class mitkPointSet;
class mitkVolumeIteratorBase;

class MITK_REGISTRATION_API mitkTransform : public mitkProcessObject
{
public:
    MITK_TYPE(mitkTransform, mitkProcessObject) 
    virtual void PrintSelf(ostream &os);

    virtual void SetParameters(const VectorParameterType& parameters);

    virtual VectorParameterType& GetParameters();

    void SetDimensions(int d[3]);
    
    const VectorIndexType& GetDimensions() const { return m_Dimensions; }

    unsigned int GetSpaceDimension() { return m_SpaceDimension; }
    
    void SetSpacings(float s[3]);
    
    const VectorParameterType& GetSpacings() const { return m_Spacings; }
        
    mitkVolume* GetOutput();

    unsigned int GetNumberOfParameters() {return m_NumberOfParameters;}

    void SetNumberOfParameters(unsigned n) { m_NumberOfParameters = n; }

    void SetCentreTransformFlag(bool flag) { m_IsCentreTransform = flag;} 

    void SetRegion(const VectorIndexType& r);

    virtual bool Update();

    //virtual vector<float>* GetJacobian(int &x, int &y, int &z);
    virtual const MatrixType & GetJacobian(const VectorParameterType& inPoint);

    virtual void TransformPoint(const ScalarIndexType &x, const ScalarIndexType &y,
                                const ScalarIndexType &z, float* outPoint);

    virtual void TransformPoint(const ScalarParameterType &x, const ScalarParameterType &y, 
                                const ScalarParameterType &z, ScalarParameterType* outPoint);

    virtual void TransformPoint(const VectorIndexType & inPoint, VectorParameterType & outPoint);

    virtual void TransformPoint(const VectorParameterType & inPoint,VectorParameterType & outPoint);

//  virtual void TransformPointInverse(const VectorIndexType & inPoint,VectorParameterType & outPoint) {}

//  virtual void TransformPointInverse(const VectorParameterType & inPoint,VectorParameterType & outPoint) {}

    void SetIdentityMatrix();
    
    virtual void ComputeTransformMatrix();

    void SetComputeMatrixFlag(bool flag) {m_FlagComputeTransform = flag;}

    void SetComputeJacobianFlag(bool flag) {m_FlagComputeJacobian = flag;}

    void SetComputeTransformParametersFlag(bool flag) { m_FlagUseTransformVector = flag; }

    void SetTransformMatrix(mitkMatrixScalarType* matrix, bool ToCentered = true);

    void SetTransformMatrix(mitkMatrixType* matrix, bool ToCentered = true);

    mitkMatrixType* GetTransformMatrix();

    mitkMatrixType* GetPreTransformMatrix();

    void GetUncenteredTransformMatrix(mitkMatrixType* mat);

    void ConcatenationTransform(mitkMatrixType* matrix, bool ToCentered = true);

    bool GetConcatenationTransformFlag() { return m_FlagConcatenationTransform; }

    virtual void SetTransformMode(int transformMode, unsigned int dim);

    int GetTransformMode() {return m_TransformMode;}

    virtual void ConvertTransformMaxtrixToVector();

    virtual void ConvertTransformVectorToMatrix();

    void ConvertMatrixToCentered(mitkMatrixType* mat);

    void ConvertMatrixToUncentered(mitkMatrixType* mat);

    bool TransformPointSet(mitkPointSet* p);

    bool TransformPointSet(mitkPointSet* p1, mitkPointSet* p2);

    bool IsLinear() { return m_IsLinear; }

    void SetRotationCenter(VectorParameterType& center);

    VectorParameterType& GetRotationCenter();

    void SetOutputDatatype(int dataType) {m_OutputDataType = dataType;}

    virtual void GetInverse();

    bool IsInversed() { return m_FlagInverseTransform; }

    inline void TransformIndexToPhysicalPoint(const VectorIndexType& idx_in,
                                              VectorParameterType& idx_out);

    void AddTransform(mitkTransform* transform);

    void RemoveTransform(mitkTransform* transform);

    void RemoveAllTransform();

#ifdef MITK_REGISTRATION_VER_OOC
    void SetOoCSupport(char const *diskPath=mitkOoCGlobalSettings::DiskCachePath, unsigned int bufSliceNum = mitkOoCGlobalSettings::BufferedSliceNumber, bool supportOoC = true);
#endif

protected:
    mitkTransform();
    virtual ~mitkTransform();
    virtual bool Execute();
    virtual void _transform(const ScalarParameterType* inPoint, ScalarParameterType* outPoint);

    mitkRCPtr<mitkVolume>                       m_OutData;

    VectorIndexType                             m_Dimensions;
    VectorParameterType                         m_Spacings;
    VectorIndexType                             m_Region;

    unsigned int                                m_SpaceDimension;
    unsigned int                                m_NumberOfParameters;

    VectorParameterType                         m_Parameters;
    MatrixType                                  m_Jacobian;
    VectorParameterType                         m_RotationCenter;
    mitkMatrixType*                             m_TransformMatrix;
    mitkMatrixType*                             m_PreTransformMatrix;

    int                                         m_TransformMode;
    int                                         m_OutputDataType;

    mitkList*                                   m_BulkTransformList;

// --------------- flags ---------------
    bool                                        m_IsCentreTransform;
    bool                                        m_IsLinear;
    bool                                        m_FlagUserDefinedCenter;
    bool                                        m_FlagComputeTransform;
    bool                                        m_FlagComputeJacobian;
    bool                                        m_FlagConcatenationTransform;
    bool                                        m_FlagUseTransformVector;
    bool                                        m_FlagInverseTransform;
    bool                                        m_FlagBulkTransform;

#ifdef MITK_REGISTRATION_VER_OOC
    bool                                        m_NeedOoC;
    unsigned int                                m_BufferedSliceNum;
    mitkString*                                 m_DiskPath;
#endif
    
private:
    mitkTransform(const mitkTransform&);
    void operator = (const mitkTransform&);
};
//-------------------------------------------------------------------------
inline void mitkTransform::TransformIndexToPhysicalPoint(const VectorIndexType& idx_in, VectorParameterType& idx_out)
{
    for(unsigned int i=0;i<m_SpaceDimension;i++) 
        idx_out[i] = static_cast<ScalarParameterType>(idx_in[i]) * m_Spacings[i];
}
//-------------------------------------------------------------------------


//#define DEFINED_mitkTransform



#endif

---