mitkWidgetModel2D.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 __mitkWidgetModel2D_h
#define __mitkWidgetModel2D_h

#include "mitkWidgetModel.h"

class mitkImageScene;
class mitkVolume;

class MITK_VISUALIZATION_API mitkWidgetModel2D : public mitkWidgetModel
{
public:
    MITK_TYPE(mitkWidgetModel2D, mitkWidgetModel)

    virtual void PrintSelf(ostream &os);

    virtual void SetScene(mitkScene *scene);

    virtual void SetSourceModel(mitkDataModel *model);
    
    void SetUnits(float ux, float uy) { m_Units[0] = ux; m_Units[1] = uy; }

    void SetUnits(float units[2]) { this->SetUnits(units[0], units[1]); }

    void SetColor(float r, float g, float b, float a = 1.0);

    void SetColor(int r, int g, int b, int a = 255);

    virtual void Update();

    virtual mitkVolume* GetCurrentImage();

    virtual mitkVolume* GetRegionMask() { return NULL; }

protected:
    mitkWidgetModel2D();
    virtual ~mitkWidgetModel2D();

    void _widgetInit();
    void _widgetFree();

    void _getOriginalCoordinates(int sx, int sy, float &ox, float &oy);
    void _getOriginalCoordinates(float objX, float objY, float &ox, float &oy);

    // Some components for widgets.
    void _drawLine(float startPos[2], float endPos[2], unsigned int name);
    void _drawLine(float x1, float y1, float x2, float y2, unsigned int name);
    void _drawArrow(float pos[2], float direction[2], float length, float width, unsigned int name);
    void _drawDisk(float center[2], float radius, unsigned int name);
    void _drawDisk(float cx, float cy, float radius, unsigned int name);
    void _drawSolidSquare(float center[2], float sideLength, unsigned int name);
    void _drawSolidSquare(float cx, float cy, float sideLength, unsigned int name);

    mitkImageScene *m_Scene;
    
    GLUquadricObj *m_QObj;
    float m_LineWidth;
    float m_ScaleLength;
    float m_RotationMatrix[16];
    float m_UsualColor[4];
    float m_Units[2];
    int   m_DiskSlice;
    

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

};

inline void mitkWidgetModel2D::_drawLine(float startPos[2], float endPos[2], unsigned int name)
{
    glLoadName((GLuint)name);
    glLineWidth(m_LineWidth);
    glBegin(GL_LINES);
        glVertex2fv(startPos);
        glVertex2fv(endPos);
    glEnd();
}

inline void mitkWidgetModel2D::_drawLine(float x1, float y1, float x2, float y2, unsigned int name)
{
    glLoadName((GLuint)name);
    glLineWidth(m_LineWidth);
    glBegin(GL_LINES);
        glVertex2f(x1, y1);
        glVertex2f(x2, y2);
    glEnd();
}

inline void mitkWidgetModel2D::_drawArrow(float pos[2], float direction[2], 
                                          float length, float width,
                                          unsigned int name)
{
    glPushMatrix();
    {
        glLoadName((GLuint)name);

        float len_inv = 1.0f / sqrtf(direction[0]*direction[0] + direction[1]*direction[1]);
        //float cosa = direction[1] * len_inv;
        //float sina = - direction[0] * len_inv;

        m_RotationMatrix[0]  = direction[1] * len_inv; //cosa
        m_RotationMatrix[1]  = - direction[0] * len_inv; //sina
//      m_RotationMatrix[2]  = 0.0f;
//      m_RotationMatrix[3]  = 0.0f;

        m_RotationMatrix[4]  = - m_RotationMatrix[1];
        m_RotationMatrix[5]  = m_RotationMatrix[0];
//      m_RotationMatrix[6]  = 0.0f;
//      m_RotationMatrix[7]  = 0.0f;

//      m_RotationMatrix[8]  = 0.0f;
//      m_RotationMatrix[9]  = 0.0f;
//      m_RotationMatrix[10] = 1.0f;
//      m_RotationMatrix[11] = 0.0f;

        m_RotationMatrix[12] = pos[0];
        m_RotationMatrix[13] = pos[1];
//      m_RotationMatrix[14] = 0.0f;
//      m_RotationMatrix[15] = 1.0f;

        glMultMatrixf(m_RotationMatrix);

//      glBegin(GL_TRIANGLE_STRIP);
//      {
//          glVertex2f(- 0.5f * width, - 2.0f * length);
//          glVertex2f(0.0f, 0.0f);
//          glVertex2f(0.0f, - length);
//          glVertex2f(0.5f * width, - 2.0f * length);
//      }
//      glEnd();
        
        glBegin(GL_TRIANGLES);
        {
            glVertex2f(0.0f, 0.0f);
            glVertex2f(- 0.5f * width, - length);
            glVertex2f(0.5f * width, -length);
        }
        glEnd();
    }
    glPopMatrix();
}

inline void mitkWidgetModel2D::_drawDisk(float cx, float cy, float radius, unsigned int name)
{
//  glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    {
        glLoadName((GLuint)name);
        glTranslatef(cx, cy, 0.0f);
        gluDisk(m_QObj, 0.0, radius, m_DiskSlice, 1);
    }
    glPopMatrix();
}

inline void mitkWidgetModel2D::_drawDisk(float center[2], float radius, unsigned int name)
{
    this->_drawDisk(center[0], center[1], radius, name);
}

inline void mitkWidgetModel2D::_drawSolidSquare(float cx, float cy, float sideLength, unsigned int name)
{
    glLoadName((GLuint)name);

    float halfLen = sideLength * 0.5f;
    glRectf(cx-halfLen, cy-halfLen, cx+halfLen, cy+halfLen);
}

inline void mitkWidgetModel2D::_drawSolidSquare(float center[2], float sideLength, unsigned int name)
{
    this->_drawSolidSquare(center[0], center[1], sideLength, name);
}


//#define DEFINED_mitkWidgetModel2D



#endif

---