mitkModel.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 __mitkModel_h
#define __mitkModel_h

#include "mitkObject.h"
#include "mitkMatrix.h"
#include "mitkQuaternion.h"
#include "mitkVisualizationIncludes.h"

class mitkScene;
class mitkObserver;

class MITK_VISUALIZATION_API mitkModel : public mitkObject
{
public:
    MITK_TYPE(mitkModel,mitkObject)

    


    enum RenderMode 
    { 
        Rough,   
        Medium,  
        Refined  
    };

    virtual void PrintSelf(ostream& os);    

    void VisibilityOn(void)     {m_Visibility = 1;}

    void VisibilityOff(void)    {m_Visibility = 0;}

    void SetVisibility(int isVisible){m_Visibility = isVisible;}

    int  GetVisibility(void) const {return m_Visibility;}   

    virtual int Render(mitkScene *scene)      { return 0; }

    virtual void Select(mitkScene *scene) {}

    void SetOrigin(float x, float y, float z) 
    { 
        m_Origin[0] = x;
        m_Origin[1] = y;
        m_Origin[2] = z;
        m_MatrixModified = 1;
    } 

    void SetOrigin(float origin[3]) 
    { 
        m_Origin[0] = origin[0];
        m_Origin[1] = origin[1];
        m_Origin[2] = origin[2];
        m_MatrixModified = 1;
    } 

    float const * GetOrigin(void) const {return m_Origin;}

    void GetOrigin(float origin[3]) const {origin[0] = m_Origin[0]; origin[1] = m_Origin[1]; origin[2] = m_Origin[2];}

    void SetTranslation(float x, float y, float z) 
    { 
        m_Translation[0] = x;
        m_Translation[1] = y;
        m_Translation[2] = z;
        m_MatrixModified = 1;
    } 

    void SetTranslation(float trans[3]) 
    { 
        m_Translation[0] = trans[0];
        m_Translation[1] = trans[1];
        m_Translation[2] = trans[2];
        m_MatrixModified = 1;
    } 

    float const * GetTranslation(void) const {return m_Translation;}

    void GetTranslation(float trans[3]) const {trans[0] = m_Translation[0]; trans[1] = m_Translation[1]; trans[2] = m_Translation[2];} 
    
    void SetRotation(float x, float y, float z)
    {
        m_Rotation->EulerDegToQuat(x, y, z);
        m_MatrixModified = 1;
    }

    void SetRotation(float rot[3])
    { 
        this->SetRotation(rot[0], rot[1], rot[2]);
    }

    void SetRotation(const mitkQuaternion &q) 
    { 
        *m_Rotation = q; 
        m_MatrixModified = 1;
    }

    void SetRotation(float ax, float ay, float az, float angle)
    {
        m_Rotation->AxisDegToQuat(ax, ay, az, angle);
        m_MatrixModified = 1;
    }

    mitkQuaternion const * GetRotation(void) const {return m_Rotation;}

    void GetRotation(float rot[3]) const { m_Rotation->GetEulerDeg(rot[0], rot[1], rot[2]); } 

    void GetRotation(float &ax, float &ay, float &az, float &angle) const
    {
        m_Rotation->GetAxisDeg(ax, ay, az, angle);
    }
    
    void SetScale(float sx, float sy, float sz)
    {
        m_Scale[0] = sx;
        m_Scale[1] = sy;
        m_Scale[2] = sz;
        m_MatrixModified = 1;
    }

    void SetScale(float scale[3])
    {
        m_Scale[0] = scale[0];
        m_Scale[1] = scale[1];
        m_Scale[2] = scale[2];
        m_MatrixModified = 1;
    }

    void SetScale(float scale) 
    { 
        m_Scale[2] = m_Scale[1] = m_Scale[0] = scale;   
        m_MatrixModified = 1;
    }
    
    float const * GetScale(void) const {return m_Scale;}

    void GetScale(float scale[3]) const
    {
        scale[0] = m_Scale[0];
        scale[1] = m_Scale[1];
        scale[2] = m_Scale[2];
    }

    void GetModelMatrix(mitkMatrix *m);

    void GetModelMatrix(float m[16]);   

    mitkMatrix const * GetModelMatrix(); 

    void GetInverseOfModelMatrix(mitkMatrix *m);

    void GetInverseOfModelMatrix(float m[16]);  

    mitkMatrix const * GetInverseOfModelMatrix(); 

    float const * GetBounds();  
    
    void GetBounds(float bounds[6]);

    void GetBounds(float &xMin, float &xMax, float &yMin, float &yMax, float &zMin, float &zMax);

    float const * GetCenter();

    void GetCenter(float c[3]);
    
    float GetLength();  

    void Reset();

    void ModelToWorld(float const modelPoint[4], float worldPoint[4]);

    void WorldToModel(float const worldPoint[4], float modelPoint[4]);

    virtual bool IsOpaque() = 0;

    bool GetDataModifyStatus() const {return m_DataChanged;}

    void SetDataModifyStatus(bool isModify) {m_DataChanged = isModify;}

    void SetRenderMode(RenderMode mode) { m_RenderMode = mode; m_RenderModeChanged=true;}

    void SetRenderModeToRough() { m_RenderMode = Rough; m_RenderModeChanged=true;}

    void SetRenderModeToMedium() { m_RenderMode = Medium; m_RenderModeChanged=true;}

    void SetRenderModeToRefined() { m_RenderMode = Refined; m_RenderModeChanged=true;}

    RenderMode GetRenderMode() const { return m_RenderMode; }

    void SetRenderModeUnchanged() { m_RenderModeChanged=false;}

    bool IsMatrixModified() const { return m_MatrixModified!=0;}
    bool IsRenderModeChanged() const {return m_RenderModeChanged;}

protected:
    mitkModel();
    virtual ~mitkModel();
    void _computeMatrix();
    virtual float* _getBounds() = 0;

    mitkMatrix    *m_Matrix;
    mitkMatrix    *m_InverseMatrix;
    //mitkMatrix    *m_RotateMatrix;
    mitkQuaternion *m_Rotation;

    float         m_Origin[3];  //Model center coordinates in object space

    float         m_Translation[3];
    //float         m_Rotation[3];
    float         m_Scale[3];

    float         m_Center[3];  //Model center coordinates in world space
    float         m_Bounds[6];

    RenderMode    m_RenderMode;

    short         m_Visibility;    
    short         m_MatrixModified;
    bool          m_DataChanged;
    bool          m_RenderModeChanged;

private:
    mitkModel(const mitkModel&);
    void operator=(const mitkModel&);

};


inline void mitkModel::ModelToWorld(float const modelPoint[4], float worldPoint[4])
{
    if(m_MatrixModified)
        this->_computeMatrix();
    mitkVector temp(modelPoint);
    temp *= *m_Matrix;
    worldPoint[0] = temp.ele[0];
    worldPoint[1] = temp.ele[1];
    worldPoint[2] = temp.ele[2];
    worldPoint[3] = temp.ele[3];
}

inline void mitkModel::WorldToModel(float const worldPoint[4], float modelPoint[4])
{
    if(m_MatrixModified)
        this->_computeMatrix();
    mitkVector temp(worldPoint);
    temp *= *m_InverseMatrix;
    modelPoint[0] = temp.ele[0];
    modelPoint[1] = temp.ele[1];
    modelPoint[2] = temp.ele[2];
    modelPoint[3] = temp.ele[3];
}


//#define DEFINED_mitkModel
 


#endif

---