mitkReslicePlaneWidgetModel.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 __mitkReslicePlaneWidgetModel_h
#define __mitkReslicePlaneWidgetModel_h

#include "mitkWidgetModel3D.h"
#include "mitkMatrix.h"
#include "mitkTrackBall.h"
#include "mitkColorTable.h"
#include "mitkRCPtr.h"

class mitkVolume;

class MITK_VISUALIZATION_API mitkReslicePlaneWidgetModel : public mitkWidgetModel3D
{
public:
    typedef float coord_type;

    MITK_TYPE(mitkReslicePlaneWidgetModel, mitkWidgetModel3D)

    virtual void PrintSelf(ostream &os);

    mitkReslicePlaneWidgetModel(coord_type v0x, coord_type v0y, coord_type v0z,
                                coord_type v1x, coord_type v1y, coord_type v1z,
                                coord_type cx,  coord_type cy,  coord_type cz);

    virtual int Render(mitkScene *scene);

    virtual void Pick(const WidgetNames &names);

    virtual void Release();

    virtual void SetSourceModel(mitkDataModel *model);

    void SetPlanePosition(coord_type v0x, coord_type v0y, coord_type v0z,
                          coord_type v1x, coord_type v1y, coord_type v1z,
                          coord_type cx,  coord_type cy,  coord_type cz);

    void SetPlaneOpacity(float opacity);

    void SetSliceOpacity(float opacity);

    float GetPlaneOpacity() { return m_PlaneOpacity;}
    
    float GetSliceOpacity() { return m_SliceOpacity;}

    void SetVolumeData(mitkVolume *vol);

    mitkVolume* GetVolumeData() { return m_VolData; }

    void SetSliceImageWidth(int width);

    void SetSliceImageHeight(int height);

    int GetSliceImageWidth() { return m_SliceImgWidth; }

    int GetSliceImageHeight() { return m_SliceImgHeight;    }
    
    void GetLeftBottomPoint(coord_type &x, coord_type &y, coord_type &z)
    {
        x = m_LeftBottom->ele[0];
        y = m_LeftBottom->ele[1];
        z = m_LeftBottom->ele[2];
    }

    mitkVector const * GetLeftBottomPoint() { return m_LeftBottom; }

    void GetRightBottomPoint(coord_type &x, coord_type &y, coord_type &z)
    {
        x = m_RightBottom->ele[0];
        y = m_RightBottom->ele[1];
        z = m_RightBottom->ele[2];
    }

    mitkVector const * GetRightBottomPoint() { return m_RightBottom; }

    void GetRightTopPoint(coord_type &x, coord_type &y, coord_type &z)
    {
        x = m_RightTop->ele[0];
        y = m_RightTop->ele[1];
        z = m_RightTop->ele[2];
    }

    mitkVector const * GetRightTopPoint() { return m_RightTop; }
    
    void GetLeftTopPoint(coord_type &x, coord_type &y, coord_type &z)
    {
        x = m_LeftTop->ele[0];
        y = m_LeftTop->ele[1];
        z = m_LeftTop->ele[2];
    }

    mitkVector const * GetLeftTopPoint() { return m_LeftTop; }

    virtual void Update();

    void EnableReslice(bool enable = true);

    void DisableReslice() { this->EnableReslice(false); }

    void SetColorTable(mitkColorTable *ct) { m_ColorTable = ct; }

    mitkColorTable* GetColorTable();

    void EnablePseudocolor(bool enable = true);

    void DisablePseudocolor() { this->EnablePseudocolor(false); }

    bool IsResliceEnabled() { return m_EnableReslice; }

    bool IsPseudocolorEnabled() { return m_EnableColor; }

    void StoreEnableState()
    {
        m_ResliceStore = m_EnableReslice;
        m_ColorStore = m_EnableColor;
        m_NeedRestore = true;
    }

    mitkVolume* GetReslicedImage();

    void RotateRadAroundXAxisOfPlane(float angle);

    void RotateRadAroundYAxisOfPlane(float angle);

    void RotateRadAroundZAxisOfPlane(float angle);

    void RotateDegAroundXAxisOfPlane(float angle);

    void RotateDegAroundYAxisOfPlane(float angle);

    void RotateDegAroundZAxisOfPlane(float angle);

    void TranslatePlane(float tx, float ty, float tz);

    void SetPlaneCenter(float ox, float oy, float oz);

    void GetPlaneNormal(float &nx, float &ny, float &nz);

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

    void SetUnitName(const string &name) { m_UnitName = name; }

    //          of the length unit this line uses
    const string& GetUnitName() { return m_UnitName; }

    float GetRotatedAngleRad();

    float GetRotatedAngleDeg();

    float GetMovedDistance();

    float GetVertMoveFromStart();

    float const * GetStartOrigin() { return m_StartOrigin; }

    void GetStartOrigin(float so[3])
    {
        so[0] = m_StartOrigin[0];
        so[1] = m_StartOrigin[1];
        so[2] = m_StartOrigin[2];
    }

    bool IsBallSelected();

    bool IsLineSelected();

protected:
    virtual ~mitkReslicePlaneWidgetModel();

    virtual float* _getBounds();

    virtual void _onMouseDown(int mouseButton, bool ctrlDown, bool shiftDown, int xPos, int yPos);

    virtual void _onMouseUp(int mouseButton, bool ctrlDown, bool shiftDown, int xPos, int yPos);

    virtual void _onMouseMove(bool ctrlDown, bool shiftDown, int xPos, int yPos, int deltaX, int deltaY);

    // Initialize.
    void _init();

    bool _reslice();
    bool _mapColor();
    bool _setDummyTexture();
    bool _updateTexture();
    void _deleteTexture();

    // Rotate plane.
    void _rotate();

    // Names of parts can be picked.
    enum
    {
        unknown,
        lbball,
        ltball,
        rbball,
        rtball,
        lline,
        tline,
        rline,
        bline,
        plane
    };

    mitkRCPtr<mitkColorTable> m_ColorTable;

    mitkVolume *m_VolData;
    mitkPlane *m_Plane;

    mitkVector *m_LeftBottom;
    mitkVector *m_RightBottom;
    mitkVector *m_RightTop;
    mitkVector *m_LeftTop;
    mitkVector *m_Normal;
    mitkVector *m_OldNormal;
    mitkMatrix *m_InvMVMatrix;
    mitkMatrix *m_RotateMatrix;

    mitkTrackBall m_TrackBall;

    float m_ArrowLength;

    float m_ArrowColor[4];
    float m_BallColor[4];
    float m_LineColor[4];
    float m_PickedBallColor[4];
    float m_PickedLineColor[4];

    float m_OldOrigin[3];
    float m_StartOrigin[3];

    float m_PlaneOpacity;
    float m_SliceOpacity;

    float m_SpacingX;
    float m_SpacingY;

    float m_MoveUnit;

    float m_ChangingValue;

    GLuint m_TexID;
    int m_DummyTexWidth;
    int m_DummyTexHeight;
    int m_SliceImgWidth;
    int m_SliceImgHeight;

    unsigned int m_BufLen;
    unsigned int m_ClrBufLen;
    unsigned char *m_TexBuf;
    unsigned char *m_ClrTexBuf;
    
    bool m_NeedSetDummyTexture;
    bool m_NeedUpdateTexture;
    bool m_BufSizeChanged;
    bool m_TexNotUpdate;
    bool m_EnableReslice;
    bool m_EnableColor;

    bool m_ResliceStore;
    bool m_ColorStore;
    bool m_NeedRestore;

    string m_UnitName;

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

};


//#define DEFINED_mitkReslicePlaneWidgetModel



#endif

---