mathplot.h

Go to the documentation of this file.

// Name:            mathplot.cpp
// Purpose:         Framework for plotting in wxWindows
// Original Author: David Schalig
// Maintainer:      Davide Rondini
// Contributors:    Jose Luis Blanco, Val Greene
// Created:         21/07/2003
// Last edit:       22/02/2009
// Copyright:       (c) David Schalig, Davide Rondini
// Licence:         wxWindows licence

#ifndef _MP_MATHPLOT_H_
#define _MP_MATHPLOT_H_

//this definition uses windows dll to export function. 
//WXDLLIMPEXP_MATHPLOT definition definition changed to WXDLLIMPEXP_MATHPLOT  
//mathplot_EXPORTS will be defined by cmake 
#ifdef mathplot_EXPORTS 
 #define WXDLLIMPEXP_MATHPLOT WXEXPORT 
 #define WXDLLIMPEXP_DATA_MATHPLOT(type) WXEXPORT type 
#else // not making DLL 
 #define WXDLLIMPEXP_MATHPLOT 
 #define WXDLLIMPEXP_DATA_MATHPLOT(type) type 
#endif

#if defined(__GNUG__) && !defined(__APPLE__)
#pragma interface "mathplot.h"
#endif

#include <vector>

// #include <wx/wx.h>
#include <wx/defs.h>
#include <wx/menu.h>
#include <wx/scrolwin.h>
#include <wx/event.h>
#include <wx/dynarray.h>
#include <wx/pen.h>
#include <wx/dcmemory.h>
#include <wx/string.h>
#include <wx/print.h>
#include <wx/image.h>


#include <deque>

// For memory leak debug
#ifdef _WINDOWS
#ifdef _DEBUG
#include <crtdbg.h>
#define DEBUG_NEW new(_NORMAL_BLOCK ,__FILE__, __LINE__)
#else
#define DEBUG_NEW new
#endif // _DEBUG
#endif // _WINDOWS

// Separation for axes when set close to border
#define X_BORDER_SEPARATION 40
#define Y_BORDER_SEPARATION 60

//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------

class WXDLLIMPEXP_MATHPLOT mpLayer;
class WXDLLIMPEXP_MATHPLOT mpFX;
class WXDLLIMPEXP_MATHPLOT mpFY;
class WXDLLIMPEXP_MATHPLOT mpFXY;
class WXDLLIMPEXP_MATHPLOT mpFXYVector;
class WXDLLIMPEXP_MATHPLOT mpScaleX;
class WXDLLIMPEXP_MATHPLOT mpScaleY;
class WXDLLIMPEXP_MATHPLOT mpWindow;
class WXDLLIMPEXP_MATHPLOT mpText;
class WXDLLIMPEXP_MATHPLOT mpPrintout;

enum
{
    mpID_FIT = 2000,    
    mpID_ZOOM_IN,       
    mpID_ZOOM_OUT,      
    mpID_CENTER,        
    mpID_LOCKASPECT,    
    mpID_HELP_MOUSE     
};

//-----------------------------------------------------------------------------
// mpLayer
//-----------------------------------------------------------------------------

typedef enum __mp_Layer_Type {
    mpLAYER_UNDEF,  
    mpLAYER_AXIS,  
    mpLAYER_PLOT,  
    mpLAYER_INFO,   
    mpLAYER_BITMAP 
} mpLayerType;

class WXDLLIMPEXP_MATHPLOT mpLayer : public wxObject
{
public:
    mpLayer();

    virtual ~mpLayer() {};

    virtual bool   HasBBox() { return TRUE; }

    virtual bool IsInfo() { return false; };

    virtual double GetMinX() { return -1.0; }

    virtual double GetMaxX() { return  1.0; }

    virtual double GetMinY() { return -1.0; }

    virtual double GetMaxY() { return  1.0; }

    virtual void   Plot(wxDC & dc, mpWindow & w) = 0;

    wxString       GetName() const { return m_name; }

    const wxFont&  GetFont() const { return m_font; }

    const wxPen&   GetPen()  const { return m_pen;  }

    void SetContinuity(bool continuity) {m_continuous = continuity;}

    bool GetContinuity() const {return m_continuous;}

    void ShowName(bool show) { m_showName = show; };

    void SetName(wxString name) { m_name = name; }

    void SetFont(wxFont& font)  { m_font = font; }

    void SetPen(wxPen pen)     { m_pen  = pen;  }

    void SetDrawOutsideMargins(bool drawModeOutside) { m_drawOutsideMargins = drawModeOutside; };

    bool GetDrawOutsideMargins() { return m_drawOutsideMargins; };

    wxBitmap GetColourSquare(int side = 16);

    mpLayerType GetLayerType() { return m_type; };
    
    bool IsVisible() {return m_visible; };

    void SetVisible(bool show) { m_visible = show; };
    
    const wxBrush&   GetBrush() const { return m_brush; };
    
    void SetBrush(wxBrush brush) { m_brush = brush; };

protected:
    wxFont   m_font;    
    wxPen    m_pen;     
    wxBrush  m_brush;       
    wxString m_name;    
    bool     m_continuous; 
    bool     m_showName;  
    bool     m_drawOutsideMargins; 
    mpLayerType m_type; 
    bool    m_visible;  
    DECLARE_DYNAMIC_CLASS(mpLayer)
};


//-----------------------------------------------------------------------------
// mpInfoLayer
//-----------------------------------------------------------------------------

class WXDLLIMPEXP_MATHPLOT mpInfoLayer : public mpLayer
{
public:
    mpInfoLayer();

    mpInfoLayer(wxRect rect, const wxBrush* brush = wxTRANSPARENT_BRUSH);

    virtual ~mpInfoLayer();

    virtual void UpdateInfo(mpWindow& w, wxEvent& event);

    virtual bool HasBBox() { return false; };

    virtual void   Plot(wxDC & dc, mpWindow & w);

    virtual bool IsInfo() { return true; };

    virtual bool Inside(wxPoint& point);

    virtual void Move(wxPoint delta);

    virtual void UpdateReference();

    wxPoint GetPosition();

    wxSize GetSize();
    
    const wxRect& GetRectangle() { return m_dim; };

protected:
    wxRect m_dim;           
    wxPoint m_reference;    
    wxBrush m_brush;        
    int m_winX, m_winY;     
    
    DECLARE_DYNAMIC_CLASS(mpInfoLayer)
};

class WXDLLIMPEXP_MATHPLOT mpInfoCoords : public mpInfoLayer
{
public:
    mpInfoCoords();
    mpInfoCoords(wxRect rect, const wxBrush* brush = wxTRANSPARENT_BRUSH);

    ~mpInfoCoords();

    virtual void UpdateInfo(mpWindow& w, wxEvent& event);

    virtual void   Plot(wxDC & dc, mpWindow & w);

protected:
    wxString m_content; 
};

class WXDLLIMPEXP_MATHPLOT mpInfoLegend : public mpInfoLayer
{
public:
    mpInfoLegend();

    mpInfoLegend(wxRect rect, const wxBrush* brush = wxTRANSPARENT_BRUSH);

    ~mpInfoLegend();

    virtual void UpdateInfo(mpWindow& w, wxEvent& event);

    virtual void   Plot(wxDC & dc, mpWindow & w);

protected:
    
};


//-----------------------------------------------------------------------------
// mpLayer implementations - functions
//-----------------------------------------------------------------------------

#define mpALIGNMASK    0x03

#define mpALIGN_RIGHT  0x00

#define mpALIGN_CENTER 0x01

#define mpALIGN_LEFT   0x02

#define mpALIGN_TOP    mpALIGN_RIGHT

#define mpALIGN_BOTTOM mpALIGN_LEFT

#define mpALIGN_BORDER_BOTTOM  0x04

#define mpALIGN_BORDER_TOP  0x05

#define mpX_NORMAL  0x00

#define mpX_TIME  0x01

#define mpX_HOURS 0x02

#define mpX_DATE 0x03

#define mpX_DATETIME 0x04

#define mpALIGN_BORDER_LEFT mpALIGN_BORDER_BOTTOM

#define mpALIGN_BORDER_RIGHT mpALIGN_BORDER_TOP

#define mpALIGN_NE     0x00

#define mpALIGN_NW     0x01

#define mpALIGN_SW     0x02

#define mpALIGN_SE     0x03

class WXDLLIMPEXP_MATHPLOT mpFX : public mpLayer
{
public:
    mpFX(wxString name = wxEmptyString, int flags = mpALIGN_RIGHT);

    virtual double GetY( double x ) = 0;

    virtual void Plot(wxDC & dc, mpWindow & w);

protected:
    int m_flags; 

    DECLARE_DYNAMIC_CLASS(mpFX)
};

class WXDLLIMPEXP_MATHPLOT mpFY : public mpLayer
{
public:
    mpFY(wxString name = wxEmptyString, int flags = mpALIGN_TOP);

    virtual double GetX( double y ) = 0;

    virtual void Plot(wxDC & dc, mpWindow & w);

protected:
    int m_flags; 

    DECLARE_DYNAMIC_CLASS(mpFY)
};

class WXDLLIMPEXP_MATHPLOT mpFXY : public mpLayer
{
public:
    mpFXY(wxString name = wxEmptyString, int flags = mpALIGN_NE);

    virtual void Rewind() = 0;

    virtual bool GetNextXY(double & x, double & y) = 0;

    virtual void Plot(wxDC & dc, mpWindow & w);


protected:
    int m_flags; 

    // Data to calculate label positioning
    wxCoord maxDrawX, minDrawX, maxDrawY, minDrawY;
    //int drawnPoints;

    void UpdateViewBoundary(wxCoord xnew, wxCoord ynew);

    DECLARE_DYNAMIC_CLASS(mpFXY)
};

class WXDLLIMPEXP_MATHPLOT mpProfile : public mpLayer
{
public:
    mpProfile(wxString name = wxEmptyString, int flags = mpALIGN_TOP);

    virtual double GetY( double x ) = 0;

    virtual void Plot(wxDC & dc, mpWindow & w);

protected:
    int m_flags; 

    DECLARE_DYNAMIC_CLASS(mpProfile)
};

//-----------------------------------------------------------------------------
// mpLayer implementations - furniture (scales, ...)
//-----------------------------------------------------------------------------

class WXDLLIMPEXP_MATHPLOT mpScaleX : public mpLayer
{
public:
    mpScaleX(wxString name = wxT("X"), int flags = mpALIGN_CENTER, bool ticks = true, unsigned int type = mpX_NORMAL);

    virtual void Plot(wxDC & dc, mpWindow & w);

    virtual bool HasBBox() { return FALSE; }

    void SetAlign(int align) { m_flags = align; };

    void SetTicks(bool ticks) { m_ticks = ticks; };

    bool GetTicks() { return m_ticks; };

    unsigned int GetLabelMode() { return m_labelType; };

    void SetLabelMode(unsigned int mode) { m_labelType = mode; };
    
    void SetLabelFormat(const wxString& format) { m_labelFormat = format; };

    const wxString& SetLabelFormat() { return m_labelFormat; };
    
protected:
    int m_flags; 
    bool m_ticks; 
    unsigned int m_labelType; 
    wxString m_labelFormat; 

    DECLARE_DYNAMIC_CLASS(mpScaleX)
};

class WXDLLIMPEXP_MATHPLOT mpScaleY : public mpLayer
{
public:
    mpScaleY(wxString name = wxT("Y"), int flags = mpALIGN_CENTER, bool ticks = true);

    virtual void Plot(wxDC & dc, mpWindow & w);

    virtual bool HasBBox() { return FALSE; }

    void SetAlign(int align) { m_flags = align; };

    void SetTicks(bool ticks) { m_ticks = ticks; };

    bool GetTicks() { return m_ticks; };
    
    void SetLabelFormat(const wxString& format) { m_labelFormat = format; };
    
    const wxString& SetLabelFormat() { return m_labelFormat; };

protected:
    int m_flags; 
    bool m_ticks; 
    wxString m_labelFormat; 

    DECLARE_DYNAMIC_CLASS(mpScaleY)
};

//-----------------------------------------------------------------------------
// mpWindow
//-----------------------------------------------------------------------------

#define mpMOUSEMODE_DRAG    0

#define mpMOUSEMODE_ZOOMBOX 1

//WX_DECLARE_HASH_MAP( int, mpLayer*, wxIntegerHash, wxIntegerEqual, wxLayerList );
typedef std::deque<mpLayer*> wxLayerList;

class WXDLLIMPEXP_MATHPLOT mpWindow : public wxWindow
{
public:
    mpWindow() {}
    mpWindow( wxWindow *parent, wxWindowID id,
                     const wxPoint &pos = wxDefaultPosition,
                     const wxSize &size = wxDefaultSize,
                     long flags = 0);
    ~mpWindow();

    wxMenu* GetPopupMenu() { return &m_popmenu; }

    bool AddLayer( mpLayer* layer, bool refreshDisplay = true);

    bool DelLayer( mpLayer* layer, bool alsoDeleteObject = false, bool refreshDisplay = true);

    void DelAllLayers( bool alsoDeleteObject, bool refreshDisplay = true);
    
    
    mpLayer* GetLayer(int position);

    mpLayer* GetLayerByName( const wxString &name);

    double GetXscl() { return m_scaleX; }
    double GetScaleX(void) const{ return m_scaleX; }; // Schaling's method: maybe another method esists with the same name

    double GetYscl() const { return m_scaleY; }
    double GetScaleY(void) const { return m_scaleY; } // Schaling's method: maybe another method exists with the same name

    double GetXpos() const { return m_posX; }
    double GetPosX(void) const { return m_posX; }

    double GetYpos() const { return m_posY; }
    double GetPosY(void) const { return m_posY; }

    int GetScrX(void) const { return m_scrX; }
    int GetXScreen(void) const { return m_scrX; }

    int GetScrY(void) const { return m_scrY; }
    int GetYScreen(void) const { return m_scrY; }

    void SetScaleX(double scaleX);

    void SetScaleY(double scaleY) { if (scaleY!=0) m_scaleY=scaleY; UpdateAll(); }

    void SetPosX(double posX) { m_posX=posX; UpdateAll(); }

    void SetPosY(double posY) { m_posY=posY; UpdateAll(); }

    void SetPos( double posX, double posY) { m_posX=posX; m_posY=posY; UpdateAll(); }

    void SetScr( int scrX, int scrY) { m_scrX=scrX; m_scrY=scrY; }
    
//     double p2x(wxCoord pixelCoordX, bool drawOutside = true ); // { return m_posX + pixelCoordX/m_scaleX; }
    inline double p2x(wxCoord pixelCoordX ) { return m_posX + pixelCoordX/m_scaleX; }

//     double p2y(wxCoord pixelCoordY, bool drawOutside = true ); //{ return m_posY - pixelCoordY/m_scaleY; }
    inline double p2y(wxCoord pixelCoordY ) { return m_posY - pixelCoordY/m_scaleY; }

//     wxCoord x2p(double x, bool drawOutside = true); // { return (wxCoord) ( (x-m_posX) * m_scaleX); }
    inline wxCoord x2p(double x) { return (wxCoord) ( (x-m_posX) * m_scaleX); }

//     wxCoord y2p(double y, bool drawOutside = true); // { return (wxCoord) ( (m_posY-y) * m_scaleY); }
    inline wxCoord y2p(double y) { return (wxCoord) ( (m_posY-y) * m_scaleY); }


    void EnableDoubleBuffer( bool enabled ) { m_enableDoubleBuffer = enabled; }

    void EnableMousePanZoom( bool enabled ) { m_enableMouseNavigation = enabled; }

    void LockAspect(bool enable = TRUE);

    inline bool IsAspectLocked() { return m_lockaspect; }

    void Fit();

    void Fit(double xMin, double xMax, double yMin, double yMax,wxCoord *printSizeX=NULL,wxCoord *printSizeY=NULL);

    void ZoomIn( const wxPoint& centerPoint = wxDefaultPosition );

    void ZoomOut( const wxPoint& centerPoint = wxDefaultPosition );

    void ZoomInX();
    void ZoomOutX();
    void ZoomInY();
    void ZoomOutY();

    void ZoomRect(wxPoint p0, wxPoint p1);

    void UpdateAll();

    // Added methods by Davide Rondini

    unsigned int CountLayers();
    
    unsigned int CountAllLayers() { return m_layers.size(); };

    //void PrintGraph(mpPrintout *print);


    double GetDesiredXmin() {return m_desiredXmin; }

    double GetDesiredXmax() {return m_desiredXmax; }

    double GetDesiredYmin() {return m_desiredYmin; }

    double GetDesiredYmax() {return m_desiredYmax; }

    void GetBoundingBox(double* bbox);
    
    void SetMPScrollbars(bool status);

    bool GetMPScrollbars() {return m_enableScrollBars; };

    bool SaveScreenshot(const wxString& filename, int type = wxBITMAP_TYPE_BMP, wxSize imageSize = wxDefaultSize, bool fit = false);

    static double zoomIncrementalFactor;

    void SetMargins(int top, int right, int bottom, int left);

    void SetMarginTop(int top) { m_marginTop = top; };
    void SetMarginRight(int right) { m_marginRight = right; };
    void SetMarginBottom(int bottom) { m_marginBottom = bottom; };
    void SetMarginLeft(int left) { m_marginLeft = left; };

    int GetMarginTop() { return m_marginTop; };
    int GetMarginRight() { return m_marginRight; };
    int GetMarginBottom() { return m_marginBottom; };
    int GetMarginLeft() { return m_marginLeft; };

    // void EnableCoordTooltip(bool value = true);
    // bool GetCoordTooltip() { return m_coordTooltip; };

    mpInfoLayer* IsInsideInfoLayer(wxPoint& point);
    
    void SetLayerVisible(const wxString &name, bool viewable);
    
    bool IsLayerVisible(const wxString &name );
    
    void SetLayerVisible(const unsigned int position, bool viewable);
    
    bool IsLayerVisible(const unsigned int position );

    void SetColourTheme(const wxColour& bgColour, const wxColour& drawColour, const wxColour& axesColour);
    
    const wxColour& GetAxesColour() { return m_axColour; };

protected:
    void OnPaint         (wxPaintEvent     &event); 
    void OnSize          (wxSizeEvent      &event); 
    // void OnScroll2       (wxScrollWinEvent &event); //!< Scroll handler, will move canvas
    void OnShowPopupMenu (wxMouseEvent     &event); 
    void OnMouseRightDown(wxMouseEvent     &event); 
    void OnCenter        (wxCommandEvent   &event); 
    void OnFit           (wxCommandEvent   &event); 
    void OnZoomIn        (wxCommandEvent   &event); 
    void OnZoomOut       (wxCommandEvent   &event); 
    void OnLockAspect    (wxCommandEvent   &event); 
    void OnMouseHelp     (wxCommandEvent   &event); 
    void OnMouseWheel    (wxMouseEvent     &event); 
    void OnMouseMove     (wxMouseEvent     &event); 
    void OnMouseLeftDown (wxMouseEvent     &event); 
    void OnMouseLeftRelease (wxMouseEvent  &event); 
    void OnScrollThumbTrack (wxScrollWinEvent &event); 
    void OnScrollPageUp     (wxScrollWinEvent &event); 
    void OnScrollPageDown   (wxScrollWinEvent &event); 
    void OnScrollLineUp     (wxScrollWinEvent &event); 
    void OnScrollLineDown   (wxScrollWinEvent &event); 
    void OnScrollTop        (wxScrollWinEvent &event); 
    void OnScrollBottom     (wxScrollWinEvent &event); 

    void DoScrollCalc    (const int position, const int orientation);

    void DoZoomInXCalc   (const int         staticXpixel);
    void DoZoomInYCalc   (const int         staticYpixel);
    void DoZoomOutXCalc  (const int         staticXpixel);
    void DoZoomOutYCalc  (const int         staticYpixel);

    virtual bool UpdateBBox();

    //wxList m_layers;    //!< List of attached plot layers
    wxLayerList m_layers; 
    wxMenu m_popmenu;   
    bool   m_lockaspect;
    // bool   m_coordTooltip; //!< Selects whether to show coordinate tooltip
    wxColour m_bgColour;    
    wxColour m_fgColour;    
    wxColour m_axColour;    

    double m_minX;      
    double m_maxX;      
    double m_minY;      
    double m_maxY;      
    double m_scaleX;    
    double m_scaleY;    
    double m_posX;      
    double m_posY;      
    int    m_scrX;      
    int    m_scrY;      
    int    m_clickedX;  
    int    m_clickedY;  

    double m_desiredXmin,m_desiredXmax,m_desiredYmin,m_desiredYmax;

    int m_marginTop, m_marginRight, m_marginBottom, m_marginLeft;

    int         m_last_lx,m_last_ly;   
    wxMemoryDC  m_buff_dc;             
    wxBitmap    *m_buff_bmp;            
    bool        m_enableDoubleBuffer;  
    bool        m_enableMouseNavigation;  
    bool        m_mouseMovedAfterRightClick;
    long        m_mouseRClick_X,m_mouseRClick_Y; 
    int         m_mouseLClick_X, m_mouseLClick_Y; 
    bool        m_enableScrollBars;
    int         m_scrollX, m_scrollY;
    mpInfoLayer* m_movingInfoLayer;      

    DECLARE_DYNAMIC_CLASS(mpWindow)
    DECLARE_EVENT_TABLE()
};

//-----------------------------------------------------------------------------
// mpFXYVector - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------

class WXDLLIMPEXP_MATHPLOT mpFXYVector : public mpFXY
{
public:
    mpFXYVector(wxString name = wxEmptyString, int flags = mpALIGN_NE);

    void SetData( const std::vector<double> &xs,const std::vector<double> &ys);

    void Clear();

protected:
    std::vector<double>  m_xs,m_ys;

    size_t              m_index;

    double              m_minX,m_maxX,m_minY,m_maxY;

    void Rewind();

    bool GetNextXY(double & x, double & y);

    double GetMinX() { return m_minX; }

    double GetMinY() { return m_minY; }

    double GetMaxX() { return m_maxX; }

    double GetMaxY() { return m_maxY; }

    int     m_flags; 

    DECLARE_DYNAMIC_CLASS(mpFXYVector)
};

//-----------------------------------------------------------------------------
// mpText - provided by Val Greene
//-----------------------------------------------------------------------------

class WXDLLIMPEXP_MATHPLOT mpText : public mpLayer
{
public:
    mpText(wxString name = wxT("Title"), int offsetx = 5, int offsety = 50);

    virtual void Plot(wxDC & dc, mpWindow & w);

    virtual bool HasBBox() { return FALSE; }

protected:
    int m_offsetx; 
    int m_offsety; 

    DECLARE_DYNAMIC_CLASS(mpText)
};


//-----------------------------------------------------------------------------
// mpPrintout - provided by Davide Rondini
//-----------------------------------------------------------------------------

class WXDLLIMPEXP_MATHPLOT mpPrintout : public wxPrintout
{
public:
    mpPrintout(mpWindow* drawWindow, const wxChar *title = _T("wxMathPlot print output"));
    virtual ~mpPrintout() {};

    void SetDrawState(bool drawState) {drawn = drawState;};
    bool OnPrintPage(int page);
    bool HasPage(int page);

private:
    bool drawn;
    mpWindow *plotWindow;
};


//-----------------------------------------------------------------------------
// mpMovableObject  - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpMovableObject : public mpLayer
{
public:
    mpMovableObject( ) :
        m_reference_x(0),
        m_reference_y(0),
        m_reference_phi(0),
        m_shape_xs(0),
        m_shape_ys(0)
    {
        m_type = mpLAYER_PLOT;
    }

    virtual ~mpMovableObject() {};

    void GetCoordinateBase( double &x, double &y, double &phi ) const
    {
        x = m_reference_x;
        y = m_reference_y;
        phi = m_reference_phi;
    }

    void SetCoordinateBase( double x, double y, double phi = 0 )
    {
        m_reference_x = x;
        m_reference_y = y;
        m_reference_phi = phi;
        m_flags  = mpALIGN_NE;
        ShapeUpdated();
    }

    virtual bool HasBBox() { return m_trans_shape_xs.size()!=0; }

    virtual double GetMinX() { return m_bbox_min_x; }

    virtual double GetMaxX() { return  m_bbox_max_x; }

    virtual double GetMinY() { return m_bbox_min_y; }

    virtual double GetMaxY() { return m_bbox_max_y; }

    virtual void   Plot(wxDC & dc, mpWindow & w);

    void SetAlign(int align) { m_flags = align; };

protected:
    int m_flags; 

    double m_reference_x,m_reference_y,m_reference_phi;

    void TranslatePoint( double x,double y, double &out_x, double &out_y );

    std::vector<double>  m_shape_xs,m_shape_ys;

    std::vector<double>  m_trans_shape_xs,m_trans_shape_ys;

    double  m_bbox_min_x,m_bbox_max_x,m_bbox_min_y,m_bbox_max_y;

    void ShapeUpdated();

};

//-----------------------------------------------------------------------------
// mpCovarianceEllipse  - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpCovarianceEllipse : public mpMovableObject
{
public:
    mpCovarianceEllipse(
        double cov_00 = 1,
        double cov_11 = 1,
        double cov_01 = 0,
        double quantiles = 2,
        int    segments = 32,
        const wxString & layerName = wxT("") ) :
            m_cov_00(cov_00),
            m_cov_11(cov_11),
            m_cov_01(cov_01),
            m_quantiles(quantiles),
            m_segments(segments)
    {
        m_continuous = true;
        m_name = layerName;
        RecalculateShape();
        m_type = mpLAYER_PLOT;
    }

    virtual ~mpCovarianceEllipse() {}

    double GetQuantiles() const { return m_quantiles; }

    void SetQuantiles(double q)
    {
        m_quantiles=q;
        RecalculateShape();
    }

    void SetSegments( int segments ) { m_segments = segments; }
    int GetSegments( ) const { return m_segments; }

    void GetCovarianceMatrix( double &cov_00,double &cov_01,double &cov_11 ) const
    {
        cov_00 = m_cov_00;
        cov_01 = m_cov_01;
        cov_11 = m_cov_11;
    }

    void SetCovarianceMatrix( double cov_00,double cov_01,double cov_11 )
    {
        m_cov_00 = cov_00;
        m_cov_01 = cov_01;
        m_cov_11 = cov_11;
        RecalculateShape();
    }

protected:
    double m_cov_00,m_cov_11,m_cov_01;
    double m_quantiles;

    int m_segments;

    void RecalculateShape();
};

//-----------------------------------------------------------------------------
// mpPolygon - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpPolygon : public mpMovableObject
{
public:
    mpPolygon( const wxString & layerName = wxT("") )
    {
        m_continuous = true;
        m_name = layerName;
    }

    virtual ~mpPolygon() {}

    void setPoints(
        const std::vector<double>&  points_xs,
        const std::vector<double>&  points_ys,
        bool                   closedShape=true );



};

//-----------------------------------------------------------------------------
// mpMovableObject  - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpBitmapLayer : public mpLayer
{
public:
    mpBitmapLayer( )
    {
        m_min_x = m_max_x =
        m_min_y = m_max_y = 0;
        m_validImg = false;
        m_type = mpLAYER_BITMAP;
    }

    virtual ~mpBitmapLayer() {};

    void GetBitmapCopy( wxImage &outBmp ) const;

    void SetBitmap( const wxImage &inBmp, double x, double y, double lx, double ly );

    virtual bool HasBBox() { return true; }

    virtual double GetMinX() { return m_min_x; }

    virtual double GetMaxX() { return  m_max_x; }

    virtual double GetMinY() { return m_min_y; }

    virtual double GetMaxY() { return m_max_y; }

    virtual void   Plot(wxDC & dc, mpWindow & w);

    void SetAlign(int align) { m_flags = align; };

protected:
    int m_flags; 

    wxImage      m_bitmap;
    wxBitmap     m_scaledBitmap;
    wxCoord      m_scaledBitmap_offset_x,m_scaledBitmap_offset_y;


    bool            m_validImg;


    double  m_min_x,m_max_x,m_min_y,m_max_y;


};



#endif // _MP_MATHPLOT_H_

---