mitkEllipseWidgetModel2D.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 __mitkEllipseWidgetModel2D_h
#define __mitkEllipseWidgetModel2D_h

#include "mitkWidgetModel2D.h"
#include <string>

using std::string;

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

    virtual void PrintSelf(ostream &os);

    mitkEllipseWidgetModel2D();

    virtual int Render(mitkScene *scene);

    virtual void Pick(const WidgetNames &names);

    virtual void Release();

    void SetCenterPoint(int scx, int scy);

    void SetCenterPoint(float cx, float cy);

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

    void SetRadius(float xr, float yr);

    void SetRadius(float r);

    void SetStartPoint(float point[2]);

    void SetStartPoint(float x, float y);

    void SetStartPoint(int sx, int sy);

    void SetMovePoint(float point[2]);

    void SetMovePoint(float x, float y);

    void SetMovePoint(int sx, int sy);

    void SetEndPoint(float point[2]);
    
    void SetEndPoint(float x, float y);

    void SetEndPoint(int sx, int sy);

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

    const string& GetUnitName() { return m_UnitName; }

    float GetArea();

    float GetPerimeter();

    void GetCenterPoint(float &tx, float &ty);

    void GetCenterPoint(int &ix, int &iy);

    void GetSemiMajorMinorAxis(float &ta, float &tb);

    void GetSemiMajorMinorAxis(int &a, int &b);

    virtual mitkVolume* GetRegionMask();

protected:
    virtual ~mitkEllipseWidgetModel2D();
    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);

    enum
    {
        unknown,
        ellipse,
        hsline,
        heline,
        vsline,
        veline,
        ssdot,
        esdot,
        eedot,
        sedot
    };

    // Initialize.
    void _init();
    
    float m_DotColor[4];
    float m_LineColor[4];
    float m_PickedLineColor[4];
    float m_PickedDotColor[4];
    float m_PickedEllipseColor[4];
    float m_PickedCircleColor[4];

    float m_CenterPoint[2];
    float m_XRadius;
    float m_YRadius;
    
    float m_StartPoint[2];
    float m_EndPoint[2];

    float m_DotSize;

    bool m_StartPointSet;
    bool m_EndPointSet;

    string m_UnitName;

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

};

inline void mitkEllipseWidgetModel2D::SetStartPoint(float x, float y)
{
    this->_getOriginalCoordinates(x, y, m_StartPoint[0], m_StartPoint[1]);
    m_CenterPoint[0] = m_EndPoint[0] = m_StartPoint[0];
    m_CenterPoint[1] = m_EndPoint[1] = m_StartPoint[1];
    m_XRadius = m_YRadius = 0.0f;
    m_StartPointSet = true;
}
inline void mitkEllipseWidgetModel2D::SetStartPoint(float point[2])
{
    this->SetStartPoint(point[0], point[1]);
}

inline void mitkEllipseWidgetModel2D::SetStartPoint(int sx, int sy)
{
    this->_getOriginalCoordinates(sx, sy, m_StartPoint[0], m_StartPoint[1]);
    m_CenterPoint[0] = m_EndPoint[0] = m_StartPoint[0];
    m_CenterPoint[1] = m_EndPoint[1] = m_StartPoint[1];
    m_XRadius = m_YRadius = 0.0f;
    m_StartPointSet = true;
}

inline void mitkEllipseWidgetModel2D::SetMovePoint(float x, float y)
{
    this->_getOriginalCoordinates(x, y, m_EndPoint[0], m_EndPoint[1]);
    m_CenterPoint[0] = (m_StartPoint[0] + m_EndPoint[0]) * 0.5f;
    m_CenterPoint[1] = (m_StartPoint[1] + m_EndPoint[1]) * 0.5f;
    m_XRadius = m_StartPoint[0]>m_CenterPoint[0] ? m_StartPoint[0]-m_CenterPoint[0] : m_CenterPoint[0]-m_StartPoint[0];
    m_YRadius = m_StartPoint[1]>m_CenterPoint[1] ? m_StartPoint[1]-m_CenterPoint[1] : m_CenterPoint[1]-m_StartPoint[1];
}

inline void mitkEllipseWidgetModel2D::SetMovePoint(float point[2])
{
    this->SetMovePoint(point[0], point[1]);
}

inline void mitkEllipseWidgetModel2D::SetMovePoint(int sx, int sy)
{
    this->_getOriginalCoordinates(sx, sy, m_EndPoint[0], m_EndPoint[1]);
    m_CenterPoint[0] = (m_StartPoint[0] + m_EndPoint[0]) * 0.5f;
    m_CenterPoint[1] = (m_StartPoint[1] + m_EndPoint[1]) * 0.5f;
    m_XRadius = m_StartPoint[0]>m_CenterPoint[0] ? m_StartPoint[0]-m_CenterPoint[0] : m_CenterPoint[0]-m_StartPoint[0];
    m_YRadius = m_StartPoint[1]>m_CenterPoint[1] ? m_StartPoint[1]-m_CenterPoint[1] : m_CenterPoint[1]-m_StartPoint[1];
}

inline void mitkEllipseWidgetModel2D::SetEndPoint(float x, float y)
{
    this->SetMovePoint(x, y);
    m_EndPointSet = true;
}

inline void mitkEllipseWidgetModel2D::SetEndPoint(float point[2])
{
    this->SetEndPoint(point[0], point[1]);
}

inline void mitkEllipseWidgetModel2D::SetEndPoint(int sx, int sy)
{
    this->SetMovePoint(sx, sy);
    m_EndPointSet = true;
}

inline void mitkEllipseWidgetModel2D::SetCenterPoint(int scx, int scy)
{
    this->_getOriginalCoordinates(scx, scy, m_CenterPoint[0], m_CenterPoint[1]);
}

inline void mitkEllipseWidgetModel2D::SetCenterPoint(float cx, float cy)
{
    this->_getOriginalCoordinates(cx, cy, m_CenterPoint[0], m_CenterPoint[1]);
}

inline void mitkEllipseWidgetModel2D::SetRadius(float xr, float yr)
{
    m_XRadius = (xr < 0) ? -xr : xr;
    m_YRadius = (yr < 0) ? -yr : yr;
}

inline void mitkEllipseWidgetModel2D::SetRadius(float r)
{
    m_XRadius = m_YRadius = (r < 0) ? -r : r;
}


//#define DEFINED_mitkEllipseWidgetModel2D



#endif

---