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, Lionel Reynaud, Dave Nadler, MortenMacFly,
//                  Oskar Waldemarsson (for multi Y axis and corrections)
// Created:         21/07/2003
// Last edit:       27/03/2026
// Copyright:       (c) David Schalig, Davide Rondini
// Licence:         wxWindows licence

#ifndef MATHPLOT_H_INCLUDED
#define MATHPLOT_H_INCLUDED

//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__) && !defined(__INTEL_CLANG_COMPILER)
#pragma interface "mathplot.h"
#endif

#include <cassert>  // For assert debug message. Disable if NDEBUG is defined
#include <vector>
#include <map>
#include <unordered_map>

// Multiple define to compile with C++14 because
// Optional is only for C++ >= 17
// Structured binding is a C++17 feature
#if (defined(__cplusplus) && (__cplusplus > 201402L)) // C++17 or newer
// Use optional
#include <optional>
typedef std::optional<unsigned int> mpOptional_uint;
typedef std::optional<int> mpOptional_int;
#define MP_OPTNULL_INT std::nullopt
#define MP_OPTTEST(opt) (opt)
#define MP_OPTGET(opt) (*opt)
// Use structured binding
#define MP_LOOP_ITER auto& [m_yID, m_yData]

#else
// To replace optional int
typedef unsigned int mpOptional_uint;
typedef int mpOptional_int;
#define MP_OPTNULL_INT -1
#define MP_OPTTEST(opt) ((opt) != -1)
#define MP_OPTGET(opt) (opt)
// To replace structured binding
#define MP_LOOP_ITER auto& elem
#define m_yID elem.first
#define m_yData elem.second
#endif

// #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 <wx/intl.h>

#include <cmath>
#include <deque>
#include <algorithm>

#if defined(MP_USER_INCLUDE)
#define header MP_USER_INCLUDE.h
#define xstr(x) #x
#define str(x) xstr(x)
#include str(header)
#undef header
#endif

// No, this is supposed to be a build parameter: #define ENABLE_MP_CONFIG
#ifdef ENABLE_MP_CONFIG
  #include "MathPlotConfig.h"
#endif // ENABLE_MP_CONFIG

// No, this is supposed to be a build parameter: #define ENABLE_MP_NAMESPACE
#ifdef ENABLE_MP_NAMESPACE
  namespace MathPlot {
#endif // ENABLE_MP_NAMESPACE

#ifdef ENABLE_MP_DEBUG
// 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
#endif // ENABLE_MP_DEBUG

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

#define mpX_LOCALTIME 0x10

#define mpX_UTCTIME 0x20
#define mpX_RAWTIME mpX_UTCTIME

#define EPSILON   1e-8
#define ISNOTNULL(x)  (fabs(x) > EPSILON)

#define EXTRA_MARGIN  8

#define ZOOM_AROUND_CENTER  -1

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

class WXDLLIMPEXP_MATHPLOT mpLayer;
class WXDLLIMPEXP_MATHPLOT mpFunction;
class WXDLLIMPEXP_MATHPLOT mpLine;
class WXDLLIMPEXP_MATHPLOT mpHorizontalLine;
class WXDLLIMPEXP_MATHPLOT mpVerticalLine;
class WXDLLIMPEXP_MATHPLOT mpFX;
class WXDLLIMPEXP_MATHPLOT mpFY;
class WXDLLIMPEXP_MATHPLOT mpFXY;
class WXDLLIMPEXP_MATHPLOT mpFXYVector;
class WXDLLIMPEXP_MATHPLOT mpProfile;
class WXDLLIMPEXP_MATHPLOT mpChart;
class WXDLLIMPEXP_MATHPLOT mpBarChart;
class WXDLLIMPEXP_MATHPLOT mpScale;
class WXDLLIMPEXP_MATHPLOT mpScaleX;
class WXDLLIMPEXP_MATHPLOT mpScaleY;
class WXDLLIMPEXP_MATHPLOT mpInfoLayer;
class WXDLLIMPEXP_MATHPLOT mpInfoCoords;
class WXDLLIMPEXP_MATHPLOT mpInfoLegend;
class WXDLLIMPEXP_MATHPLOT mpWindow;
class WXDLLIMPEXP_MATHPLOT mpText;
class WXDLLIMPEXP_MATHPLOT mpTitle;
class WXDLLIMPEXP_MATHPLOT mpPrintout;
class WXDLLIMPEXP_MATHPLOT mpMovableObject;
class WXDLLIMPEXP_MATHPLOT mpCovarianceEllipse;
class WXDLLIMPEXP_MATHPLOT mpPolygon;
class WXDLLIMPEXP_MATHPLOT mpBitmapLayer;

#ifdef ENABLE_MP_CONFIG
class MathPlotConfigDialog;
#endif // ENABLE_MP_CONFIG

typedef union
{
    struct
    {
        wxCoord startPx;
        wxCoord endPx;
        wxCoord startPy;
        wxCoord endPy;
    };
    struct
    {
        wxCoord left;
        wxCoord top;
        wxCoord right;
        wxCoord bottom;
    };
    struct
    {
        wxCoord x1;
        wxCoord y1;
        wxCoord x2;
        wxCoord y2;
    };
    wxCoord tab[4];
} mpRect;

template<typename T>
struct mpRange
{
    T min = 0;  
    T max = 0;  

    mpRange()
    {
      min = 0;
      max = 0;
    }

    mpRange(T value1, T value2)
    {
      if (value1 < value2)
      {
        min = value1;
        max = value2;
      }
      else
      {
        min = value2;
        max = value1;
      }
    }

    void Set(T _value)
    {
      min = _value;
      max = _value;
    }

    void Set(T _min, T _max)
    {
      min = _min;
      max = _max;
    }

    void SetMin(T _min)
    {
      min = _min;
      if (max < min)
        max = min;
    }

    void SetMax(T _max)
    {
      max = _max;
      if (min > max)
        min = max;
    }

    void Assign(T value1, T value2)
    {
      if (value1 < value2)
      {
        min = value1;
        max = value2;
      }
      else
      {
        min = value2;
        max = value1;
      }
    }

    bool IsSet()
    {
      return ((min != 0) || (max != 0));
    }

    void Update(T value)
    {
      if (value < min)
        min = value;
      else
        if (value > max)
          max = value;
    }

    void Update(T _min, T _max)
    {
      if (_min < min)
        min = _min;
      if (_max > max)
        max = _max;
    }

    void Update(mpRange range)
    {
      if (range.min < min)
        min = range.min;
      if (range.max > max)
        max = range.max;
    }

    void Check(void)
    {
      if (min == max)
      {
        if (max > 0)
          min = 0;
        else
          max = 0;
      }
    }

    T Length(void) const
    {
      return max - min;
    }

    T GetCenter(void) const
    {
      return (min + max) / 2;
    }

    T GetMaxAbs(void) const
    {
      return std::max(fabs(min), fabs(max));
    }

    void ToLog(void)
    {
      min = (min > 0) ? log10(min) : 0;
      max = (max > 0) ? log10(max) : 0;
    }

    bool PointIsInside(T point) const
    {
      return ((point >= min) && (point <= max));
    }

#if (defined(__cplusplus) && (__cplusplus > 201703L)) // C++20 or newer
    bool operator==(const mpRange&) const = default;
#else
    bool operator==(const mpRange &other) const
    {
      return (min == other.min) && (max == other.max);
    }
    bool operator!=(const mpRange& other) const
    {
      return !(*this == other);
    }
#endif
};

struct [[deprecated("No more used, X and Y are now separated")]] mpFloatRect
{
  mpRange<double> x;               
  std::vector<mpRange<double>> y;  

  mpFloatRect(mpWindow& w);

  mpFloatRect() = delete;

  bool PointIsInside(double px, double py, size_t yAxisID = 0) const {
    if (yAxisID < y.size())
    {
      if( (px < x.min || px > x.max) ||
          (py < y[yAxisID].min || py > y[yAxisID].max))
      {
        return false;
      }
    }
    else
    {
      return false;
    }

    return true;
  }

  void UpdateBoundingBoxToInclude(double px, double py, size_t yAxisID = 0) {
    assert(yAxisID < y.size());
    if (yAxisID < y.size())
    {
      if      (px  < x.min ) x.min = px;
      else if (px  > x.max ) x.max = px;
      if      (py  < y[yAxisID].min ) y[yAxisID].min = py;
      else if (py  > y[yAxisID].max ) y[yAxisID].max = py;
    }
  }

  void InitializeBoundingBox(double px, double py, size_t yAxisID = 0) {
    assert(yAxisID < y.size());
    if (yAxisID < y.size())
    {
      x.min = x.max = px;
      y[yAxisID].min = y[yAxisID].max = py;
    }
  }
  bool IsNotSet(mpWindow& w) const { const mpFloatRect def(w); return *this==def; }
#if (defined(__cplusplus) && (__cplusplus > 201703L)) // C++ > C++17 (MSVC requires <AdditionalOptions>/Zc:__cplusplus</AdditionalOptions>
  bool operator==(const mpFloatRect&) const = default;
#else
  // We compare with an epsilon precision
  // NOTE: should be unnecessary as we are looking for any changes; normally this will be an exact match or a real change...
  bool operator==(const mpFloatRect& rect) const
  {
    auto Same = [](double a, double b) {
      return std::fabs(a - b) < EPSILON;
    };

    // Compare scalar members
    if (!Same(x.min, rect.x.min) || !Same(x.max, rect.x.max))
    {
      return false;
    }

    // Compare vector sizes
    if (y.size() != rect.y.size())
    {
      return false;
    }

    // Compare each Y boundary
    for (size_t i = 0; i < y.size(); ++i)
    {
      if (!Same(y[i].min, rect.y[i].min) ||
          !Same(y[i].max, rect.y[i].max)  )
      {
        return false;
      }
    }

    return true;
  }
#endif
};

struct mpFloatRectSimple
{
  mpRange<double> x;   
  mpRange<double> y;   

  mpFloatRectSimple(mpRange<double> _x, mpRange<double> _y) : x(_x), y(_y) { };

  bool PointIsInside(double px, double py) const {
    return x.PointIsInside(px) && y.PointIsInside(py);
  }

  void UpdateBoundingBoxToInclude(double px, double py)
  {
    x.Update(px);
    y.Update(py);
  }

  void InitializeBoundingBox(double px, double py)
  {
    x.Set(px, px);
    y.Set(py, py);
  }
};

enum
{
  mpID_FIT = 2000,         
  mpID_ZOOM_IN,            
  mpID_ZOOM_OUT,           
  mpID_CENTER,             
  mpID_LOCKASPECT,         
  mpID_TOGGLE_GRID,        
  mpID_TOGGLE_COORD,       
  mpID_SCREENSHOT,         
#ifdef ENABLE_MP_CONFIG
  mpID_CONFIG,             
#endif // ENABLE_MP_CONFIG
  mpID_LOAD_FILE,          
  mpID_HELP_MOUSE,         
  mpID_FULLSCREEN          
};

typedef enum __mp_Location_Type
{
  mpMarginLeftCenter,    
  mpMarginTopLeft,       
  mpMarginTopCenter,     
  mpMarginTopRight,      
  mpMarginRightCenter,   
  mpMarginBottomLeft,    
  mpMarginBottomCenter,  
  mpMarginBottomRight,   
  mpMarginNone,          
  mpCursor               
} mpLocation;

typedef enum __XAxis_Align_Type
{
  mpALIGN_BORDER_BOTTOM = 10, 
  mpALIGN_BOTTOM,             
  mpALIGN_CENTERX,            
  mpALIGN_TOP,                
  mpALIGN_BORDER_TOP          
} mpXAxis_Align;

typedef enum __YAxis_Align_Type
{
  mpALIGN_BORDER_LEFT = 20, 
  mpALIGN_LEFT,             
  mpALIGN_CENTERY,          
  mpALIGN_RIGHT,            
  mpALIGN_BORDER_RIGHT      
} mpYAxis_Align;

typedef enum __Plot_Align_Name_Type
{
  mpALIGN_NW = 5,  
  mpALIGN_NE,      
  mpALIGN_SE,      
  mpALIGN_SW       
} mpPlot_Align;

typedef enum __mp_Style_Type
{
  mpLegendLine,    
  mpLegendSquare,  
  mpLegendSymbol   
} mpLegendStyle;

typedef enum __mp_Direction_Type
{
  mpVertical,      
  mpHorizontal     
} mpLegendDirection;

typedef enum __Symbol_Type
{
  mpsNone,         
  mpsCircle,       
  mpsSquare,       
  mpsUpTriangle,   
  mpsDownTriangle, 
  mpsCross,        
  mpsPlus          
} mpSymbol;

//-----------------------------------------------------------------------------
// mpLayer sub_type values
//-----------------------------------------------------------------------------

typedef enum __Info_Type
{
  mpiNone,     
  mpiInfo,     
  mpiCoords,   
  mpiLegend    
} mpInfoType;

typedef enum __Text_Type
{
  mptNone,     
  mptText,     
  mptTitle     
} mpTextType;

typedef enum __Function_Type
{
  mpfNone,       
  mpfFX,         
  mpfFY,         
  mpfFXY,        
  mpfFXYVector,  
  mpfMovable,    
  mpfLine,       
  mpfAllType     
} mpFunctionType;

typedef enum __Scale_Type
{
  mpsScaleNone,     
  mpsScaleX,        
  mpsScaleY,        
  mpsAllType        
} mpScaleType;

typedef enum __Chart_Type
{
  mpcChartNone,     
  mpcBarChart,      
  mpcPieChart,      
  mpcAllType        
} mpChartType;

enum mpMouseButtonAction
{
  mpMouseBoxZoom,     
  mpMouseDragZoom,    
};

enum mpLabelType
{
  mpLabel_AUTO,
  mpLabel_DECIMAL,
  mpLabel_SCIENTIFIC,
  mpLabel_TIME,
  mpLabel_HOURS,
  mpLabel_DATE,
  mpLabel_DATETIME,
  mpLabel_USER,
  mpLabel_NONE,
};

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

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

typedef enum __mp_Layer_ZOrder
{
  mpZIndex_BACKGROUND,   
  mpZIndex_AXIS,         
  mpZIndex_LINE,         
  mpZIndex_PLOT,         
  mpZIndex_CHART,        
  mpZIndex_INFO,         
  mpZIndex_TEXT,         
  mpZIndex_END           
} mpLayerZOrder;

typedef enum __mp_Delete_Action
{
  mpNoDelete,     
  mpYesDelete,    
  mpForceDelete   
} mpDeleteAction;

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

    virtual ~mpLayer()
    {
      ;
    }

    void SetWindow(mpWindow &w)
    {
      m_win = &w;
    }

    virtual bool HasBBox()
    {
      return true;
    }

    mpLayerType GetLayerType() const
    {
      return m_type;
    }

    int GetLayerSubType() const
    {
      return m_subtype;
    }

    virtual bool IsLayerType(mpLayerType typeOfInterest, int *subtype)
    {
      *subtype = m_subtype;
      return (m_type == typeOfInterest);
    }

    virtual double GetMinX()
    {
      return -1.0;
    }

    virtual double GetMaxX()
    {
      return 1.0;
    }

    virtual double GetMinY()
    {
      return -1.0;
    }

    virtual double GetMaxY()
    {
      return 1.0;
    }

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

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

    const wxString& GetName() const
    {
      return m_name;
    }

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

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

    void SetFontColour(const wxColour &colour)
    {
      m_fontcolour = colour;
    }

    const wxColour& GetFontColour() const
    {
      return m_fontcolour;
    }

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

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

    void SetBrush(const wxBrush &brush)
    {
      if (brush == wxNullBrush)
        m_brush = *wxTRANSPARENT_BRUSH;
      else
        m_brush = brush;
    }

    const wxBrush& GetBrush() const
    {
      return m_brush;
    }

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

    inline bool GetShowName() const
    {
      return m_showName;
    }

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

    bool GetDrawOutsideMargins() const
    {
      return m_drawOutsideMargins;
    }

    wxBitmap GetColourSquare(int side = 16);

    inline bool IsVisible() const
    {
      return m_visible;
    }

    virtual void SetVisible(bool show)
    {
      m_visible = show;
    }

    inline bool IsTractable() const
    {
      return m_tractable;
    }

    virtual void SetTractable(bool track)
    {
      m_tractable = track;
    }

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

    int GetAlign() const
    {
      return m_flags;
    }

    void SetCanDelete(bool canDelete)
    {
      m_CanDelete = canDelete;
    }

    bool GetCanDelete(void) const
    {
      return m_CanDelete;
    }

    mpLayerZOrder GetZIndex(void) const
    {
      return m_ZIndex;
    }

  protected:
    const mpLayerType m_type;   
    mpWindow* m_win;            
    int m_subtype;              
    wxFont m_font;              
    wxColour m_fontcolour;      
    wxPen m_pen;                
    wxBrush m_brush;            
    wxString m_name;            
    bool m_showName;            
    bool m_drawOutsideMargins;  
    bool m_visible;             
    bool m_tractable;           
    int m_flags;                
    mpRect m_plotBoundaries;    
    bool m_CanDelete;           
    mpLayerZOrder m_ZIndex;     

    void UpdateContext(wxDC &dc) const;

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

    virtual bool DoBeforePlot()
    {
      return true;
    }

    void CheckLog(double *x, double *y, int yAxisID);

  private:
    bool m_busy;          
    mpLayer() = delete;   // default ctor not implemented/permitted

  wxDECLARE_DYNAMIC_CLASS(mpLayer);
};

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

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

    mpInfoLayer(wxRect rect, const wxBrush &brush = *wxTRANSPARENT_BRUSH, mpLocation location = mpMarginNone);

    virtual ~mpInfoLayer();

    virtual void SetVisible(bool show);

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

    virtual bool HasBBox()
    {
      return false;
    }

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

    virtual bool Inside(const wxPoint &point);

    virtual void Move(wxPoint delta);

    virtual void UpdateReference();

    wxPoint GetPosition() const
    {
      return m_dim.GetPosition();
    }

    wxSize GetSize() const
    {
      return m_dim.GetSize();
    }

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

    void SetLocation(mpLocation location)
    {
      m_location = location;
    }

    mpLocation GetLocation() const
    {
      return m_location;
    }

  protected:
    wxRect m_dim;           
    wxRect m_oldDim;        
    wxBitmap* m_info_bmp;   
    wxPoint m_reference;    
    int m_winX, m_winY;     
    mpLocation m_location;  

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

    void SetInfoRectangle(mpWindow &w, int width = 0, int height = 0);

  wxDECLARE_DYNAMIC_CLASS(mpInfoLayer);
};

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

    mpInfoCoords(mpLocation location);

    mpInfoCoords(wxRect rect, const wxBrush &brush = *wxTRANSPARENT_BRUSH, mpLocation location = mpMarginNone);

    ~mpInfoCoords()
    {
      ;
    }

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

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

    void SetLabelMode(mpLabelType mode, unsigned int time_conv = mpX_RAWTIME)
    {
      m_labelType = mode;
      m_timeConv = time_conv;
    }

    void SetSeriesCoord(bool show)
    {
      m_series_coord = show;
    }

    bool IsSeriesCoord() const
    {
      return m_series_coord;
    }

    virtual wxString GetInfoCoordsText(mpWindow &w, double xVal, std::unordered_map<int, double> yValList);

    void SetPenSeries(const wxPen &pen)
    {
      m_penSeries = pen;
    }

  protected:
    wxString m_content;  
    mpLabelType m_labelType;
    unsigned int m_timeConv;
    wxCoord m_mouseX;
    wxCoord m_mouseY;
    bool m_series_coord;
    wxPen m_penSeries;

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

  wxDECLARE_DYNAMIC_CLASS(mpInfoCoords);
};

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

    mpInfoLegend(wxRect rect, const wxBrush &brush = *wxWHITE_BRUSH, mpLocation location = mpMarginNone);

    ~mpInfoLegend() {}

    void SetItemMode(mpLegendStyle mode)
    {
      m_item_mode = mode;
      m_needs_update = true;
    }

    mpLegendStyle GetItemMode() const
    {
      return m_item_mode;
    }

    void SetItemDirection(mpLegendDirection mode)
    {
      m_item_direction = mode;
      m_needs_update = true;
    }

    mpLegendDirection GetItemDirection() const
    {
      return m_item_direction;
    }

    void SetNeedUpdate()
    {
      m_needs_update = true;
    }

    int GetPointed(mpWindow &w, wxPoint eventPoint);

  protected:
    mpLegendStyle m_item_mode;
    mpLegendDirection m_item_direction;

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

  private:
    struct LegendDetail
    {
        unsigned int layerIdx; 
        wxCoord legendEnd;     
    };
    std::vector<LegendDetail> m_LegendDetailList; 
    bool m_needs_update; 

    void UpdateBitmap(wxDC &dc, mpWindow &w);

  wxDECLARE_DYNAMIC_CLASS(mpInfoLegend);
};

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

class WXDLLIMPEXP_MATHPLOT mpFunction: public mpLayer
{
  public:
    mpFunction(mpLayerType layerType = mpLAYER_PLOT, const wxString &name = wxEmptyString, unsigned int yAxisID = 0);

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

    bool GetContinuity() const
    {
      return m_continuous;
    }

    void SetStep(unsigned int step)
    {
      m_step = step;
    }

    unsigned int GetStep() const
    {
      return m_step;
    }

    void SetSymbol(mpSymbol symbol)
    {
      m_symbol = symbol;
    }

    mpSymbol GetSymbol() const
    {
      return m_symbol;
    }

    void SetSymbolSize(int size)
    {
      m_symbolSize = size;
      m_symbolSize2 = size / 2;
    }

    int GetSymbolSize() const
    {
      return m_symbolSize;
    }

    virtual bool DrawSymbol(wxDC &dc, wxCoord x, wxCoord y);

    int GetYAxisID() const
    {
      return m_yAxisID;
    }

    void SetYAxisID(unsigned int yAxisID)
    {
      m_yAxisID = yAxisID;
    }

  protected:
    bool m_continuous;          
    mpSymbol m_symbol;          
    int m_symbolSize;           
    int m_symbolSize2;          
    unsigned int m_step;        
    int m_yAxisID;              

  wxDECLARE_DYNAMIC_CLASS(mpFunction);
};

class WXDLLIMPEXP_MATHPLOT mpLine: public mpFunction
{
  public:
    mpLine(double value, const wxPen &pen = *wxGREEN_PEN);

    // We don't want to include line (horizontal or vertical) in BBox computation
    virtual bool HasBBox() override
    {
      return false;
    }

    double GetValue() const
    {
      return m_value;
    }

    void SetValue(const double value)
    {
      m_value = value;
    }

    bool IsHorizontal(void) const
    {
      return m_IsHorizontal;
    }

  protected:
    double m_value;        
    bool m_IsHorizontal;   

    wxDECLARE_DYNAMIC_CLASS(mpLine);
};

class WXDLLIMPEXP_MATHPLOT mpHorizontalLine: public mpLine
{
  public:
    mpHorizontalLine(double yvalue, const wxPen &pen = *wxGREEN_PEN, unsigned int yAxisID = 0);

    void SetYValue(const double yvalue)
    {
      SetValue(yvalue);
    }

  protected:

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

    wxDECLARE_DYNAMIC_CLASS(mpHorizontalLine);
};

class WXDLLIMPEXP_MATHPLOT mpVerticalLine: public mpLine
{
  public:
    mpVerticalLine(double xvalue, const wxPen &pen = *wxGREEN_PEN);

    void SetXValue(const double xvalue)
    {
      SetValue(xvalue);
    }

  protected:

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

    virtual bool DoBeforePlot()
    {
      return true;
    }

    wxDECLARE_DYNAMIC_CLASS(mpVerticalLine);
};

class WXDLLIMPEXP_MATHPLOT mpFX: public mpFunction
{
  public:
    mpFX(const wxString &name = wxEmptyString, int flags = mpALIGN_RIGHT, unsigned int yAxisID = 0);

    virtual double GetY(double x) = 0;

    double DoGetY(double x);

    void DefineDoGetY(void);

  protected:

    // Pointer function to the appropriate DoGetY function
    double (mpFX::*pDoGetY)(double x);

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

    double NormalDoGetY(double x);

    double LogDoGetY(double x);

  wxDECLARE_DYNAMIC_CLASS(mpFX);
};

class WXDLLIMPEXP_MATHPLOT mpFY: public mpFunction
{
  public:
    mpFY(const wxString &name = wxEmptyString, int flags = mpALIGN_TOP, unsigned int yAxisID = 0);

    virtual double GetX(double y) = 0;

    double DoGetX(double y);

    void DefineDoGetX(void);

  protected:

    // Pointer function to the appropriate DoGetX function
    double (mpFY::*pDoGetX)(double y);

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

    double NormalDoGetX(double y);

    double LogDoGetX(double y);

  wxDECLARE_DYNAMIC_CLASS(mpFY);
};

class WXDLLIMPEXP_MATHPLOT mpFXY: public mpFunction
{
  public:
    mpFXY(const wxString &name = wxEmptyString, int flags = mpALIGN_SW, bool viewAsBar = false, unsigned int yAxisID = 0);

    virtual void Rewind() = 0;

    virtual void Clear()
    {
      ;
    }

    virtual int GetSize()
    {
      return 0;
    }

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

    bool DoGetNextXY(double *x, double *y);

    void SetViewMode(bool asBar);

    int GetBarWidth(void) const
    {
      return m_BarWidth;
    }

    bool ViewAsBar(void) const
    {
      return m_ViewAsBar;
    }

  protected:

    // Data to calculate label positioning
    mpRange<int> m_drawX;    
    mpRange<int> m_drawY;    

    // Min delta between 2 x coordinate (used for view as bar)
    double m_deltaX;    
    double m_deltaY;    

    // The width of a bar
    int m_BarWidth;

    // Plot data as bar graph
    bool m_ViewAsBar = false;

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

    void UpdateViewBoundary(wxCoord xnew, wxCoord ynew);

  wxDECLARE_DYNAMIC_CLASS(mpFXY);
};

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

class WXDLLIMPEXP_MATHPLOT mpFXYVector: public mpFXY
{
  public:
    mpFXYVector(const wxString &name = wxEmptyString, int flags = mpALIGN_SW, bool viewAsBar = false, unsigned int yAxisID = 0);

    virtual ~mpFXYVector()
    {
      Clear();
    }

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

    void Clear();

    virtual int GetSize()
    {
      return m_xs.size();
    }

    bool AddData(const double x, const double y, bool updatePlot);

    void SetReserve(int reserve)
    {
      m_reserveXY = reserve;
      m_xs.reserve(m_reserveXY);
      m_ys.reserve(m_reserveXY);
    }

    int GetReserve() const
    {
      return m_reserveXY;
    }

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

    int m_reserveXY;

    size_t m_index;

    mpRange<double> m_rangeX;    
    double m_lastX;              
    mpRange<double> m_rangeY;    
    double m_lastY;              

    inline void Rewind()
    {
      m_index = 0;
    }

    virtual bool GetNextXY(double *x, double *y);

    void DrawAddedPoint(double x, double y);

    virtual double GetMinX()
    {
      if (m_ViewAsBar)
      {
        // Make extra space for outer bars
        return m_rangeX.min - (m_deltaX / 2);
      }
      else
      {
        return m_rangeX.min;
      }
    }

    virtual double GetMinY()
    {
      return m_rangeY.min;
    }

    virtual double GetMaxX()
    {
      if(m_ViewAsBar)
      {
        // Make extra space for outer bars
        return m_rangeX.max + (m_deltaX / 2);
      }
      else
      {
        return m_rangeX.max;
      }
    }

    virtual double GetMaxY()
    {
      return m_rangeY.max;
    }

  private:
    void First_Point(double x, double y);

    void Check_Limit(double val, mpRange<double> *range, double *last, double *delta);

  wxDECLARE_DYNAMIC_CLASS(mpFXYVector);
};

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

    virtual double GetY(double x) = 0;

  protected:

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

  wxDECLARE_DYNAMIC_CLASS(mpProfile);
};

//-----------------------------------------------------------------------------
// mpChart
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpChart: public mpFunction
{
  public:
    mpChart(const wxString &name = wxEmptyString);

    ~mpChart()
    {
      Clear();
    }

    void SetChartValues(const std::vector<double> &data);

    void SetChartLabels(const std::vector<std::string> &labelArray);

    void AddData(const double &data, const std::string &label);

    virtual void Clear();

    virtual bool HasBBox()
    {
      return (values.size() > 0);
    }

  protected:
    std::vector<double> values;       
    std::vector<std::string> labels;  

    double m_max_value;               
    double m_total_value;             

    wxDECLARE_DYNAMIC_CLASS(mpChart);
};

//-----------------------------------------------------------------------------
// mpBarChart  - provided by Jose Davide Rondini
//-----------------------------------------------------------------------------
/* Defines for bar charts label positioning. */
#define mpBAR_NONE      0       
#define mpBAR_AXIS_H    1       
#define mpBAR_AXIS_V    2       
#define mpBAR_INSIDE    3       
#define mpBAR_TOP       4       


class WXDLLIMPEXP_MATHPLOT mpBarChart: public mpChart
{
  public:
    mpBarChart(const wxString &name = wxEmptyString, double width = 0.5);

    ~mpBarChart()
    {
      Clear();
    }

    void SetBarColour(const wxColour &colour);

    void SetColumnWidth(const double colWidth)
    {
      m_width = colWidth;
    }

    void SetBarLabelPosition(int position);

    virtual double GetMinX();

    virtual double GetMaxX();

    virtual double GetMinY();

    virtual double GetMaxY();

  protected:

    double m_width;
    wxColour m_barColour;
    int m_labelPos;
    double m_labelAngle;

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

    wxDECLARE_DYNAMIC_CLASS(mpBarChart);
};

class WXDLLIMPEXP_MATHPLOT mpPieChart: public mpChart
{
  public:
    mpPieChart(const wxString &name = wxEmptyString, double radius = 20);

    ~mpPieChart()
    {
      Clear();
      colours.clear();
    }

    void SetCenter(const wxPoint center)
    {
      m_center = center;
    }

    wxPoint GetCenter(void) const
    {
      return m_center;
    }

    void SetPieColours(const std::vector<wxColour> &colourArray);

    virtual double GetMinX()
    {
      return m_center.x - m_radius;
    }

    virtual double GetMaxX()
    {
      return m_center.x + m_radius;
    }

    virtual double GetMinY()
    {
      return m_center.y - m_radius;
    }

    virtual double GetMaxY()
    {
      return m_center.y + m_radius;
    }

  protected:

    double m_radius;
    wxPoint m_center;
    std::vector<wxColour> colours;

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

    const wxColour& GetColour(unsigned int id);

    wxDECLARE_DYNAMIC_CLASS(mpBarChart);
};

//-----------------------------------------------------------------------------
// mpLayer implementations - furniture (scales, ...)
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpScale: public mpLayer
{
  public:
    mpScale(const wxString &name, int flags, bool grids, mpLabelType labelType = mpLabel_AUTO, mpOptional_uint axisID = MP_OPTNULL_INT);

    virtual bool HasBBox()
    {
      return false;
    }

    int GetAxisID(void)
    {
      return m_axisID;
    }

    void SetAxisID(unsigned int yAxisID)
    {
      m_axisID = yAxisID;
    }

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

    bool GetShowTicks() const
    {
      return m_ticks;
    }

    void ShowGrids(bool grids)
    {
      m_grids = grids;
    }

    bool GetShowGrids() const
    {
      return m_grids;
    }

    void SetLabelFormat(const wxString &format, bool updateLabelMode = false)
    {
      m_labelFormat = format;
      if (updateLabelMode)
        m_labelType = mpLabel_USER;
    }

    mpLabelType GetLabelMode() const
    {
      return m_labelType;
    }

    void SetLabelMode(mpLabelType mode, unsigned int time_conv = mpX_RAWTIME)
    {
      m_labelType = mode;
      m_timeConv = time_conv;
    }

    const wxString& GetLabelFormat() const
    {
      return m_labelFormat;
    }

    void SetGridPen(const wxPen &pen)
    {
      m_gridpen = pen;
    }

    const wxPen& GetGridPen() const
    {
      return m_gridpen;
    }

    void SetAuto(bool automaticScalingIsEnabled)
    {
      m_auto = automaticScalingIsEnabled;
    }

    bool GetAuto() const
    {
      return m_auto;
    }

    void SetMinScale(double min)
    {
      m_axisRange.SetMin(min);
    }

    double GetMinScale() const
    {
      return m_axisRange.min;
    }

    void SetMaxScale(double max)
    {
      m_axisRange.SetMax(max);
    }

    double GetMaxScale() const
    {
      return m_axisRange.max;
    }

    void SetScale(double min, double max)
    {
      m_axisRange.Set(min, max);
    }

    void GetScale(double *min, double *max) const
    {
      *min = m_axisRange.min;
      *max = m_axisRange.max;
    }

    void SetScale(mpRange<double> range)
    {
      m_axisRange = range;
    }

    mpRange<double> GetScale() const
    {
      return mpRange<double>(m_axisRange);
    }

    virtual bool IsLogAxis()
    {
      return m_isLog;
    }

    virtual void SetLogAxis(bool log)
    {
      m_isLog = log;
    }

  protected:
    static const wxCoord kTickSize = 4;       
    static const wxCoord kAxisExtraSpace = 6; 

    int m_axisID;                
    wxPen m_gridpen;             
    bool m_ticks;                
    bool m_grids;                
    bool m_auto;                 
    mpRange<double> m_axisRange; 
    mpLabelType m_labelType;     
    unsigned int m_timeConv;     
    wxString m_labelFormat;      
    bool m_isLog;                

    virtual int GetOrigin(mpWindow &w) = 0;

    double GetStep(double scale, int minLabelSpacing);

    virtual void DrawScaleName(wxDC &dc, mpWindow &w, int origin, int labelSize) = 0;

    wxString FormatLabelValue(double value, double maxAxisValue, double step);

    wxString FormatLogValue(double n);

    int GetLabelWidth(double value, wxDC &dc, double maxAxisValue, double step);

    bool UseScientific(double maxAxisValue);

    int GetSignificantDigits(double step, double maxAxisValue);

    int GetDecimalDigits(double step);

  wxDECLARE_DYNAMIC_CLASS(mpScale);
};


class WXDLLIMPEXP_MATHPLOT mpScaleX: public mpScale
{
  public:
    mpScaleX(const wxString &name = _T("X"), int flags = mpALIGN_CENTERX, bool grids = false, mpLabelType type = mpLabel_AUTO) :
        mpScale(name, flags, grids, type)
    {
      m_subtype = mpsScaleX;
    }

    bool IsTopAxis()
    {
      return ((GetAlign() == mpALIGN_BORDER_TOP) || (GetAlign() == mpALIGN_TOP));
    }

    bool IsBottomAxis()
    {
      return ((GetAlign() == mpALIGN_BORDER_BOTTOM) || (GetAlign() == mpALIGN_BOTTOM));
    }

  protected:

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

    virtual int GetOrigin(mpWindow &w);
    virtual void DrawScaleName(wxDC &dc, mpWindow &w, int origin, int labelSize);

  wxDECLARE_DYNAMIC_CLASS(mpScaleX);
};

class WXDLLIMPEXP_MATHPLOT mpScaleY: public mpScale
{
  public:
    mpScaleY(const wxString &name = _T("Y"), int flags = mpALIGN_CENTERY, bool grids = false, mpOptional_uint yAxisID = MP_OPTNULL_INT, mpLabelType labelType = mpLabel_AUTO) :
        mpScale(name, flags, grids, labelType, yAxisID)
    {
      m_subtype = mpsScaleY;
      m_axisWidth = Y_BORDER_SEPARATION;
      m_xPos = 0;
    }

    void UpdateAxisWidth(mpWindow &w);

    int GetAxisWidth()
    {
      return m_axisWidth;
    }

    bool IsLeftAxis()
    {
      return ((GetAlign() == mpALIGN_BORDER_LEFT) || (GetAlign() == mpALIGN_LEFT));
    }

    bool IsRightAxis()
    {
      return ((GetAlign() == mpALIGN_BORDER_RIGHT) || (GetAlign() == mpALIGN_RIGHT));
    }

    bool IsInside(wxCoord xPixel)
    {
      if ( (IsLeftAxis() || IsRightAxis()) && (xPixel >= m_xPos) && (xPixel <= (m_xPos + m_axisWidth)) )
      {
        return true;
      }
      return false;
    }

  protected:
    int m_axisWidth;
    int m_xPos;

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

    virtual int GetOrigin(mpWindow &w);
    virtual void DrawScaleName(wxDC &dc, mpWindow &w, int origin, int labelSize);

  wxDECLARE_DYNAMIC_CLASS(mpScaleY);
};

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

#define mpMOUSEMODE_DRAG    0

#define mpMOUSEMODE_ZOOMBOX 1

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

struct mpAxisData
{
    mpScale* axis = nullptr;  
    double scale = 1.0;       
    double pos = 0;           
    mpRange<double> bound;            
    mpRange<double> desired;          
    mpRange<double> lastDesired;      

    // Note: we don't use the default operator since we don't want to compare axis pointers
    bool operator==(const mpAxisData& other) const
    {
      return /*(axis == other.axis) && */ (scale == other.scale) && (pos == other.pos) &&
          (bound == other.bound) && (desired == other.desired);
    }
};

typedef std::unordered_map<int, mpAxisData> mpAxisList;

typedef enum {
  uXAxis = 1,
  uYAxis = 2,
  uXYAxis = 3
} mpAxisUpdate;

typedef std::function<void(void *Sender, const wxString &classname, bool &cancel)> mpOnDeleteLayer;

typedef std::function<void(void *Sender, wxMouseEvent &event, bool &cancel)> mpOnUserMouseAction;

class mpMagnet
{
  public:
    mpMagnet()
    {
      m_IsDrawn = false;
      m_rightClick = false;
      m_IsWasDrawn = false;
    }
    ~mpMagnet()
    {
      ;
    }
    void UpdateBox(wxCoord left, wxCoord top, wxCoord width, wxCoord height)
    {
      m_domain = wxRect(left, top, width, height);
      m_plot_size = wxRect(left, top, width + left, height + top);
    }
    void UpdateBox(const wxRect &size)
    {
      m_domain = size;
      m_plot_size = wxRect(size.GetLeft(), size.GetTop(),
          size.GetWidth() + size.GetLeft(), size.GetHeight() + size.GetTop());
    }
    void Plot(wxClientDC &dc, const wxPoint &mousePos);
    void ClearPlot(wxClientDC &dc);
    void UpdatePlot(wxClientDC &dc, const wxPoint &mousePos);
    void SaveDrawState(void)
    {
      m_IsWasDrawn = m_IsDrawn;
      // In any cases, set to false because we erase and repaint all the plot
      m_IsDrawn = false;
    }

    void SetRightClick(void)
    {
      m_rightClick = true;
    }

  private:
    wxRect m_domain;           
    wxRect m_plot_size;        
    wxPoint m_mousePosition;   
    bool m_IsDrawn;            
    bool m_IsWasDrawn;         
    bool m_rightClick;         
    void DrawCross(wxClientDC &dc) const;
};

class WXDLLIMPEXP_MATHPLOT mpWindow: public wxWindow
{
  public:
    mpWindow()
    {
      InitParameters();
    }

    mpWindow(wxWindow *parent, wxWindowID id = wxID_ANY, 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 refreshConfig = true);

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

    void DelAllLayers(mpDeleteAction alsoDeleteObject, bool refreshDisplay = true);

    void DelAllPlot(mpDeleteAction alsoDeleteObject, mpFunctionType func = mpfAllType, bool refreshDisplay = true);

    void DelAllYAxisAfterID(mpDeleteAction alsoDeleteObject, int yAxisID = 0, bool refreshDisplay = true);

    mpLayer* GetLayer(int position);

    int GetLayerPosition(mpLayer* layer);

    mpLayer* GetLayersType(int position, mpLayerType type);

    mpLayer* GetLayerPlot(int position, mpFunctionType func = mpfAllType);

    mpScale* GetLayerAxis(int position, mpScaleType scale = mpsAllType);

    mpFXYVector* GetXYSeries(unsigned int n, const wxString &name = _T("Serie "), bool create = true);

    mpLayer* GetClosestPlot(wxCoord ix, wxCoord iy, double *xnear, double *ynear);

    mpLayer* GetLayerByName(const wxString &name);

    mpLayer* GetLayerByClassName(const wxString &name);

    void RefreshLegend(void);

    bool IsYAxisUsed(int yAxisID);

    mpScaleX* GetLayerXAxis();

    mpScaleY* GetLayerYAxis(int yAxisID);

    void SetScaleX(const double scaleX)
    {
      if (ISNOTNULL(scaleX))
      {
        m_AxisDataX.scale = scaleX;
        UpdateDesiredBoundingBox(uXAxis);
      }
      UpdateAll();
    }

    double GetScaleX(void) const
    {
      return m_AxisDataX.scale;
    }

    void SetScaleY(const double scaleY, int yAxisID)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      if (ISNOTNULL(scaleY))
      {
        m_AxisDataYList[yAxisID].scale = scaleY;
        UpdateDesiredBoundingBox(uYAxis);
      }
      UpdateAll();
    }

    double GetScaleY(int yAxisID)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      return m_AxisDataYList[yAxisID].scale;
    } // Schaling's method: maybe another method exists with the same name

    [[deprecated("Incomplete, use UpdateBBox instead")]]
    void SetBound();

    mpRange<double> GetBoundX(void) const
    {
      return m_AxisDataX.bound;
    }

    mpRange<double> GetDesiredBoundX(void) const
    {
      return m_AxisDataX.desired;
    }

    mpRange<double> GetBoundY(int yAxisID)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      return m_AxisDataYList[yAxisID].bound;
    }

    mpRange<double> GetDesiredBoundY(int yAxisID)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      return m_AxisDataYList[yAxisID].desired;
    }

    std::unordered_map<int, mpRange<double>> GetAllBoundY()
    {
      std::unordered_map<int, mpRange<double>> yRange;
      for (const MP_LOOP_ITER : m_AxisDataYList)
      {
        yRange[m_yID] = m_yData.bound;
      }
      return yRange;
    }

    std::unordered_map<int, mpRange<double>> GetAllDesiredY()
    {
      std::unordered_map<int, mpRange<double>> yRange;
      for (const MP_LOOP_ITER : m_AxisDataYList)
      {
        yRange[m_yID] = m_yData.desired;
      }
      return yRange;
    }

    void SetPosX(const double posX)
    {
      m_AxisDataX.pos = posX;
      UpdateDesiredBoundingBox(uXAxis);
      UpdateAll();
    }

    double GetPosX(void) const
    {
      return m_AxisDataX.pos;
    }

    void SetPosY(std::unordered_map<int, double>& posYList)
    {
      for (MP_LOOP_ITER : m_AxisDataYList)
      {
        m_yData.pos = posYList[m_yID];
      }
      UpdateDesiredBoundingBox(uYAxis);
      UpdateAll();
    }

    double GetPosY(int yAxisID)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      return m_AxisDataYList[yAxisID].pos;
    }

    int GetNOfYAxis(void) const
    {
      return (int)m_AxisDataYList.size();
    }

    mpAxisList GetAxisDataYList(void) const
    {
      return m_AxisDataYList;
    }

    std::map<int, mpAxisData> GetSortedAxisDataYList(void) const
    {
      return std::map<int, mpAxisData>(m_AxisDataYList.begin(), m_AxisDataYList.end());
    }

    void SetScreen(const int scrX, const int scrY)
    {
      m_scrX = scrX;
      m_scrY = scrY;
      m_plotWidth = m_scrX - (m_margin.left + m_margin.right);
      m_plotHeight = m_scrY - (m_margin.top + m_margin.bottom);

      m_plotBoundaries.endPx = m_scrX;
      m_plotBoundariesMargin.endPx = m_scrX - m_margin.right;
      m_plotBoundaries.endPy = m_scrY;
      m_plotBoundariesMargin.endPy = m_scrY - m_margin.bottom;

      m_PlotArea = wxRect(m_margin.left - m_extraMargin, m_margin.top - m_extraMargin,
          m_plotWidth + 2*m_extraMargin, m_plotHeight + 2*m_extraMargin);

      m_magnet.UpdateBox(m_PlotArea);
    }

    int GetScreenX(void) const
    {
      return m_scrX;
    }

    int GetScreenY(void) const
    {
      return m_scrY;
    }

    void SetPos(const double posX, std::unordered_map<int, double>& posYList)
    {
      m_AxisDataX.pos = posX;
      SetPosY(posYList);
    }

    inline double p2x(const wxCoord pixelCoordX) const
    {
      return m_AxisDataX.pos + (pixelCoordX / m_AxisDataX.scale);
    }

    inline double p2y(const wxCoord pixelCoordY, int yAxisID = 0)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      if (m_AxisDataYList.count(yAxisID) == 0)
        return 0.0;
      return m_AxisDataYList[yAxisID].pos - (pixelCoordY / m_AxisDataYList[yAxisID].scale);
    }

    inline wxCoord x2p(const double x) const
    {
      return (wxCoord)((x - m_AxisDataX.pos) * m_AxisDataX.scale);
    }

    inline wxCoord y2p(const double y, int yAxisID = 0)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      if (m_AxisDataYList.count(yAxisID) == 0)
        return 0;
      return (wxCoord)((m_AxisDataYList[yAxisID].pos - y) * m_AxisDataYList[yAxisID].scale);
    }

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

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

    void LockAspect(bool enable = true);

    inline bool IsAspectLocked() const
    {
      return m_lockaspect;
    }

    inline bool IsRepainting() const
    {
      return m_repainting;
    }

    void Fit();

    void Fit(const mpRange<double> &rangeX, std::unordered_map<int, mpRange<double>> rangeY, wxCoord *printSizeX = NULL, wxCoord *printSizeY = NULL);

    void FitX(void);

    void FitY(int yAxisID);

    void ZoomIn(const wxPoint &centerPoint = wxDefaultPosition);

    void ZoomOut(const wxPoint &centerPoint = wxDefaultPosition);

    void ZoomInX();

    void ZoomOutX();

    void ZoomInY(mpOptional_int yAxisID = MP_OPTNULL_INT);

    void ZoomOutY(mpOptional_int yAxisID = MP_OPTNULL_INT);

    void ZoomRect(wxPoint p0, wxPoint p1);

    void UpdateAll();

    // Added methods by Davide Rondini

    unsigned int CountLayers();

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

    unsigned int CountLayersType(mpLayerType type);

    unsigned int CountLayersFXYPlot();

    void UpdateDesiredBoundingBox(mpAxisUpdate update)
    {
      // Change on X axis
      if (update & uXAxis)
      {
        m_AxisDataX.desired.Set(m_AxisDataX.pos + (m_margin.left / m_AxisDataX.scale),
            m_AxisDataX.pos + ((m_margin.left + m_plotWidth) / m_AxisDataX.scale));
      }

      // Change on Y axis
      if (update & uYAxis)
      {
        for (MP_LOOP_ITER : m_AxisDataYList)
        {
          m_yData.desired.Set(m_yData.pos - ((m_margin.top + m_plotHeight) / m_yData.scale),
              m_yData.pos - (m_margin.top / m_yData.scale));
        }
      }
    }

    mpFloatRectSimple GetBoundingBox(bool desired, unsigned int yAxisID = 0)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      if (desired)
        return mpFloatRectSimple(m_AxisDataX.desired, m_AxisDataYList[yAxisID].desired);
      else
        return mpFloatRectSimple(m_AxisDataX.bound, m_AxisDataYList[yAxisID].bound);
    }

    double GetDesiredXmin() const
    {
      return m_AxisDataX.desired.min;
    }

    double GetDesiredXmax() const
    {
      return m_AxisDataX.desired.max;
    }

    double GetDesiredYmin(int yAxisID)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      return m_AxisDataYList[yAxisID].desired.min;
    }

    double GetDesiredYmax(int yAxisID)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      return m_AxisDataYList[yAxisID].desired.max;
    }

    bool GetBoundingBox(mpRange<double> *boundX, mpRange<double> *boundY, int yAxisID)
    {
      if (m_AxisDataYList.count(yAxisID) == 0)
        return false;
      *boundX = m_AxisDataX.bound;
      *boundY = m_AxisDataYList[yAxisID].bound;
      return true;
    }

    // Is this point inside the bounding box
    bool PointIsInsideBound(double px, double py, int yAxisID)
    {
      if (m_AxisDataYList.count(yAxisID) == 0)
        return false;

      return m_AxisDataX.bound.PointIsInside(px) && GetBoundY(yAxisID).PointIsInside(py);
    }

    /* Update bounding box (X and Y axis) to include this point.
     * Expand the range to include the point.
     * @param px: point on x-axis
     * @param py: point on y-axis
     * @param yAxisID: the y-axis ID
     */
    void UpdateBoundingBoxToInclude(double px, double py, int yAxisID)
    {
      if (m_AxisDataYList.count(yAxisID) == 0)
        return ;

      m_AxisDataX.bound.Update(px);
      m_AxisDataYList[yAxisID].bound.Update(py);
    }

    /* Initialize bounding box with an initial point
     * @param px: point on x-axis
     * @param py: point on y-axis
     * @param yAxisID: the y-axis ID
     */
    void InitializeBoundingBox(double px, double py, int yAxisID)
    {
      if (m_AxisDataYList.count(yAxisID) == 0)
        return ;

      m_AxisDataX.bound.Set(px, px);
      m_AxisDataYList[yAxisID].bound.Set(py, py);
    }

    void SetMPScrollbars(bool status);

    bool GetMPScrollbars() const
    {
      return m_enableScrollBars;
    }

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

    wxBitmap* BitmapScreenshot(wxSize imageSize = wxDefaultSize, bool fit = false);

    void ClipboardScreenshot(wxSize imageSize = wxDefaultSize, bool fit = false);

    void SetWildcard(const wxString &wildcard)
    {
      m_wildcard = wildcard;
    }

    const wxString& GetWildcard(void) const
    {
      return m_wildcard;
    }

    bool LoadFile(const wxString &filename = wxEmptyString);

    void SetDefaultDir(const wxString &dirname)
    {
      m_DefaultDir = dirname;
    }

    static double m_zoomIncrementalFactor;

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

    void UpdateMargins()
    {
      SetMargins(m_marginOuter.top, m_marginOuter.right, m_marginOuter.bottom, m_marginOuter.left);
    }

    void SetMarginTop(int top)
    {
      SetMargins(top, m_marginOuter.right, m_marginOuter.bottom, m_marginOuter.left);
    }

    int GetMarginTop(bool minusExtra = false) const
    {
      if (minusExtra)
        return m_margin.top - m_extraMargin;
      else
        return m_margin.top;
    }

    void SetMarginRight(int right)
    {
      SetMargins(m_marginOuter.top, right, m_marginOuter.bottom, m_marginOuter.left);
    }

    int GetMarginRight(bool minusExtra = false) const
    {
      if (minusExtra)
        return m_margin.right - m_extraMargin;
      else
        return m_margin.right;
    }

    int GetMarginRightOuter() const
    {
      return m_marginOuter.right;
    }

    void SetMarginBottom(int bottom)
    {
      SetMargins(m_marginOuter.top, m_marginOuter.right, bottom, m_marginOuter.left);
    }

    int GetMarginBottom(bool minusExtra = false) const
    {
      if (minusExtra)
        return m_margin.bottom - m_extraMargin;
      else
        return m_margin.bottom;
    }

    void SetMarginLeft(int left)
    {
      SetMargins(m_marginOuter.top, m_marginOuter.right, m_marginOuter.bottom, left);
    }

    int GetMarginLeft(bool minusExtra = false) const
    {
      if (minusExtra)
        return m_margin.left - m_extraMargin;
      else
        return m_margin.left;
    }

    void SetExtraMargin(int extra)
    {
      m_extraMargin = extra;
      SetMargins(m_marginOuter.top, m_marginOuter.right, m_marginOuter.bottom, m_marginOuter.left);
    }

    int GetExtraMargin() const
    {
      return m_extraMargin;
    }

    int GetMarginLeftOuter() const
    {
      return m_marginOuter.left;
    }

    int GetPlotWidth() const
    {
      return m_plotWidth;
    }

    int GetPlotHeight() const
    {
      return m_plotHeight;
    }

    mpRect GetPlotBoundaries(bool with_margin) const
    {
      mpRect bond;
      if (with_margin)
        bond = m_plotBoundariesMargin;
      else
        bond = m_plotBoundaries;
      bond.startPx -= m_extraMargin;
      bond.endPx += m_extraMargin;
      bond.startPy -= m_extraMargin;
      bond.endPy += m_extraMargin;
      return bond;
    }

    int GetLeftYAxesWidth(mpOptional_int yAxisID = MP_OPTNULL_INT);

    int GetRightYAxesWidth(mpOptional_int yAxisID = MP_OPTNULL_INT);

    void SetDrawBox(bool drawbox)
    {
      m_drawBox = drawbox;
    }

    bool GetDrawBox() const
    {
      return m_drawBox;
    }

    mpOptional_int IsInsideYAxis(const wxPoint &point);

    mpInfoLayer* IsInsideInfoLayer(const wxPoint &point);

    void SetLayerVisible(const wxString &name, bool viewable);

    bool IsLayerVisible(const wxString &name);

    bool IsLayerVisible(const unsigned int position);

    void SetLayerVisible(const unsigned int position, bool viewable);

    void SetColourTheme(const wxColour &bgColour, const wxColour &drawColour, const wxColour &axesColour);

    const wxColour& GetAxesColour() const
    {
      return m_axColour;
    }

    const wxColour& GetbgColour() const
    {
      return m_bgColour;
    }

    void SetbgColour(const wxColour &colour)
    {
      m_bgColour = colour;
    }

    void SetOnDeleteLayer(const mpOnDeleteLayer &event)
    {
      m_OnDeleteLayer = event;
    }

    void UnSetOnDeleteLayer()
    {
      m_OnDeleteLayer = NULL;
    }

    void SetOnUserMouseAction(const mpOnUserMouseAction &userMouseEventHandler)
    {
      m_OnUserMouseAction = userMouseEventHandler;
    }

    void UnSetOnUserMouseAction()
    {
      m_OnUserMouseAction = NULL;
    }

    bool IsLogXaxis()
    {
      if (m_AxisDataX.axis)
        return ((mpScaleX *)m_AxisDataX.axis)->IsLogAxis();
      else
        return false;
    }

    bool IsLogYaxis(int yAxisID)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      mpScaleY* yAxis = GetLayerYAxis(yAxisID);
      if (yAxis)
        return yAxis->IsLogAxis();
      else
        return false;
    }

    void SetLogXaxis(bool log)
    {
      if (m_AxisDataX.axis)
        ((mpScaleX *)m_AxisDataX.axis)->SetLogAxis(log);
    }

    void SetLogYaxis(int yAxisID, bool log)
    {
      mpScaleY* yAxis = GetLayerYAxis(yAxisID);
      if (yAxis)
        yAxis->SetLogAxis(log);
    }

    bool GetMagnetize() const
    {
      return m_magnetize;
    }

    void SetMagnetize(bool mag)
    {
      m_magnetize = mag;
    }

    void SetMouseLeftDownAction(mpMouseButtonAction action)
    {
      m_mouseLeftDownAction = action;
    }

    mpMouseButtonAction GetMouseLeftDownAction()
    {
      return m_mouseLeftDownAction;
    }

#ifdef ENABLE_MP_CONFIG
    void RefreshConfigWindow();
    MathPlotConfigDialog* GetConfigWindow(bool Create = false);
    void DeleteConfigWindow(void);
#endif // ENABLE_MP_CONFIG

  protected:
    virtual void BindEvents(void);                                
    virtual void OnPaint(wxPaintEvent &event);                    
    virtual void OnSize(wxSizeEvent &event);                      
    virtual void OnShowPopupMenu(wxMouseEvent &event);            
    virtual void OnCenter(wxCommandEvent &event);                 
    virtual void OnFit(wxCommandEvent &event);                    
    virtual void OnToggleGrids(wxCommandEvent &event);            
    virtual void OnToggleCoords(wxCommandEvent &event);           
    virtual void OnScreenShot(wxCommandEvent &event);             
    virtual void OnFullScreen(wxCommandEvent &event);             
#ifdef ENABLE_MP_CONFIG
    virtual void OnConfiguration(wxCommandEvent &event);          
#endif // ENABLE_MP_CONFIG
    virtual void OnLoadFile(wxCommandEvent &event);               
    virtual void OnZoomIn(wxCommandEvent &event);                 
    virtual void OnZoomOut(wxCommandEvent &event);                
    virtual void OnLockAspect(wxCommandEvent &event);             
    virtual void OnMouseHelp(wxCommandEvent &event);              
    virtual void OnMouseLeftDown(wxMouseEvent &event);            
    virtual void OnMouseRightDown(wxMouseEvent &event);           
    virtual void OnMouseMove(wxMouseEvent &event);                
    virtual void OnMouseLeftRelease(wxMouseEvent &event);         
    virtual void OnMouseWheel(wxMouseEvent &event);               
    virtual void OnMouseLeave(wxMouseEvent &event);               
    bool CheckUserMouseAction(wxMouseEvent &event);               
    virtual void OnScrollThumbTrack(wxScrollWinEvent &event);     
    virtual void OnScrollPageUp(wxScrollWinEvent &event);         
    virtual void OnScrollPageDown(wxScrollWinEvent &event);       
    virtual void OnScrollLineUp(wxScrollWinEvent &event);         
    virtual void OnScrollLineDown(wxScrollWinEvent &event);       
    virtual void OnScrollTop(wxScrollWinEvent &event);            
    virtual void OnScrollBottom(wxScrollWinEvent &event);         

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

    void DoZoomXCalc(bool zoomIn, wxCoord staticXpixel = ZOOM_AROUND_CENTER);

    void DoZoomYCalc(bool zoomIn, wxCoord staticYpixel = ZOOM_AROUND_CENTER, mpOptional_int yAxisID = MP_OPTNULL_INT);

    void SetScaleXAndCenter(double scaleX);

    void SetScaleYAndCenter(double scaleY, int yAxisID);

    void Zoom(bool zoomIn, const wxPoint &centerPoint);

    virtual bool UpdateBBox();

    void InitParameters();

    wxTopLevelWindow* m_parent;  
    bool m_fullscreen;           

    mpLayerList m_layers;        
    mpAxisData m_AxisDataX;      
    mpAxisList m_AxisDataYList;  

    wxMenu m_popmenu;       
    bool m_lockaspect;      
    wxColour m_bgColour;    
    wxColour m_fgColour;    
    wxColour m_axColour;    
    bool m_drawBox;         

    int m_scrX;             
    int m_scrY;             
    int m_clickedX;         
    int m_clickedY;         

    mpRect m_margin;                    
    mpRect m_marginOuter;               
    int m_extraMargin;                  
    wxCoord m_plotWidth;                
    wxCoord m_plotHeight;               

    mpRect m_plotBoundaries;            
    mpRect m_plotBoundariesMargin;      
    wxRect m_PlotArea;                  

    bool m_repainting;                  
    int m_last_lx, m_last_ly;           
    wxBitmap* m_buff_bmp;               
    bool m_enableDoubleBuffer;          
    bool m_enableMouseNavigation;       
    mpMouseButtonAction m_mouseLeftDownAction;  
    bool m_mouseMovedAfterRightClick;   
    wxPoint m_mouseRClick;              
    wxPoint m_mouseLClick;              
    double m_mouseScaleX;               
    std::unordered_map<int, double> m_mouseScaleYList;  
    mpOptional_int m_mouseYAxisID;      
    bool m_enableScrollBars;            
    mpInfoLayer* m_movingInfoLayer;     
    mpInfoCoords* m_InfoCoords;         
    mpInfoLegend* m_InfoLegend;         
    bool m_InInfoLegend;                

    wxBitmap* m_zoom_bmp;               
    wxRect m_zoom_Dim;                  

    bool m_magnetize;                   
    mpMagnet m_magnet;                  

    wxBitmap* m_Screenshot_bmp;         

    wxString m_wildcard;                
    wxString m_DefaultDir;              

#ifdef ENABLE_MP_CONFIG
    MathPlotConfigDialog* m_configWindow = NULL;  
#endif // ENABLE_MP_CONFIG

    mpOnDeleteLayer m_OnDeleteLayer = NULL;          
    mpOnUserMouseAction m_OnUserMouseAction = NULL;  

    virtual void DesiredBoundsHaveChanged() {};

  private:
    void CheckAndReportDesiredBoundsChanges();

    unsigned int GetNewAxisDataID(void)
    {
      int newID = 0;
      for (const MP_LOOP_ITER : m_AxisDataYList)
      {
        if(m_yData.axis)
        {
          // This ID is used by an axis. Make sure the new ID is larger
          newID = std::max(newID, m_yID + 1);
        }
      }
      return newID;
    }

  wxDECLARE_DYNAMIC_CLASS(mpWindow);

    // To have direct access to m_Screenshot_dc
    friend mpPrintout;
};

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

class WXDLLIMPEXP_MATHPLOT mpText: public mpLayer
{
  public:
    mpText(const wxString &name = wxEmptyString) : mpLayer(mpLAYER_TEXT)
    {
      m_subtype = mptText;
      SetName(name);
      m_offsetx = 5;
      m_offsety = 50;
      m_location = mpMarginNone;
      m_ZIndex = mpZIndex_TEXT;
    }

    mpText(const wxString &name, int offsetx, int offsety);

    mpText(const wxString &name, mpLocation marginLocation);

    virtual bool HasBBox()
    {
      return false;
    }

    void SetLocation(mpLocation location)
    {
      m_location = location;
    }

    mpLocation GetLocation() const
    {
      return m_location;
    }

    void SetOffset(int offX, int offY)
    {
      m_offsetx = offX;
      m_offsety = offY;
    }

    void GetOffset(int *offX, int *offY) const
    {
      *offX = m_offsetx;
      *offY = m_offsety;
    }

  protected:
    int m_offsetx;  
    int m_offsety;  
    mpLocation m_location;  

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

  wxDECLARE_DYNAMIC_CLASS(mpText);
};

class WXDLLIMPEXP_MATHPLOT mpTitle: public mpText
{
  public:
    mpTitle();

    mpTitle(const wxString &name) :
        mpText(name, mpMarginTopCenter)
    {
      m_subtype = mptTitle;
      SetPen(*wxWHITE_PEN);
      SetBrush(*wxWHITE_BRUSH);
    }

  protected:

  wxDECLARE_DYNAMIC_CLASS(mpTitle);
};

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

class WXDLLIMPEXP_MATHPLOT mpPrintout: public wxPrintout
{
  public:
    mpPrintout()
    {
      plotWindow = NULL;
      drawn = false;
      stretch_factor = 2;
    }

    mpPrintout(mpWindow *drawWindow, const wxString &title = _T("wxMathPlot print output"), int factor = 2);
    virtual ~mpPrintout()
    {
      ;
    }

    void SetDrawState(bool drawState)
    {
      drawn = drawState;
    }

    bool OnPrintPage(int page);
    bool HasPage(int page);

    void SetFactor(int factor)
    {
      stretch_factor = factor;
    }

  private:
    bool drawn;
    mpWindow* plotWindow;
    int stretch_factor;  // To reduce the size of plot

  protected:

  wxDECLARE_DYNAMIC_CLASS(mpPrintout);
};

//-----------------------------------------------------------------------------
// mpMovableObject  - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpMovableObject: public mpFunction
{
  public:
    mpMovableObject() :
        m_reference_x(0), m_reference_y(0), m_reference_phi(0), m_shape_xs(0), m_shape_ys(0)
    {
      assert(m_type == mpLAYER_PLOT); // m_type is already set to mpLAYER_PLOT in default-arg mpFunction ctor: m_type = mpLAYER_PLOT;
      m_subtype = mpfMovable;
    }

    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_SW;
      ShapeUpdated();
    }

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

    virtual double GetMinX()
    {
      return m_bbox_x.min;
    }

    virtual double GetMaxX()
    {
      return m_bbox_x.max;
    }

    virtual double GetMinY()
    {
      return m_bbox_y.min;
    }

    virtual double GetMaxY()
    {
      return m_bbox_y.max;
    }

  protected:

    double m_reference_x, m_reference_y, m_reference_phi;

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

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

    std::vector<double> m_shape_xs, m_shape_ys;

    std::vector<double> m_trans_shape_xs, m_trans_shape_ys;

    mpRange<double> m_bbox_x;   
    mpRange<double> m_bbox_y;   

    void ShapeUpdated();

  wxDECLARE_DYNAMIC_CLASS(mpMovableObject);
};

//-----------------------------------------------------------------------------
// 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 = _T("")) : mpMovableObject(),
        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();
    }

    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();

  wxDECLARE_DYNAMIC_CLASS(mpCovarianceEllipse);
};

//-----------------------------------------------------------------------------
// mpPolygon - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpPolygon: public mpMovableObject
{
  public:
    mpPolygon(const wxString &layerName = _T("")) : mpMovableObject()
    {
      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);

  protected:

  wxDECLARE_DYNAMIC_CLASS(mpPolygon);
};

//-----------------------------------------------------------------------------
// mpBitmapLayer - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpBitmapLayer: public mpLayer
{
  public:
    mpBitmapLayer() : mpLayer(mpLAYER_BITMAP)
    {
      m_validImg = false;
      m_bitmapChanged = false;
      m_scaledBitmap_offset_x = m_scaledBitmap_offset_y = 0;
    }

    virtual ~mpBitmapLayer()
    {
      ;
    }

    void GetBitmapCopy(wxImage &outBmp) const;

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

    virtual double GetMinX()
    {
      return m_bitmapX.min;
    }

    virtual double GetMaxX()
    {
      return m_bitmapX.max;
    }

    virtual double GetMinY()
    {
      return m_bitmapY.min;
    }

    virtual double GetMaxY()
    {
      return m_bitmapY.max;
    }

  protected:

    wxImage m_bitmap;
    wxBitmap m_scaledBitmap;
    wxCoord m_scaledBitmap_offset_x, m_scaledBitmap_offset_y;
    bool m_validImg;
    bool m_bitmapChanged;

    mpRange<double> m_bitmapX;  // Range of the bitmap on x direction
    mpRange<double> m_bitmapY;  // Range of the bitmap on y direction

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

  wxDECLARE_DYNAMIC_CLASS(mpBitmapLayer);
};

// utility class

typedef enum __mp_Colour
{
  mpBlue,
  mpRed,
  mpGreen,
  mpPurple,
  mpYellow,
  mpFuchsia,
  mpLime,
  mpAqua,
  mpOlive
} mpColour;

class WXDLLIMPEXP_MATHPLOT wxIndexColour: public wxColour
{
  public:
    wxIndexColour(unsigned int id)
    {
      switch (id)
      {
        case 0:
          this->Set(0, 0, 255);
          break;  // Blue
        case 1:
          this->Set(255, 0, 0);
          break;  // Red
        case 2:
          this->Set(0, 128, 0);
          break;  // Green
        case 3:
          this->Set(128, 0, 128);
          break;  // Purple
        case 4:
          this->Set(255, 255, 0);
          break;  // Yellow
        case 5:
          this->Set(255, 0, 255);
          break;  // Fuchsia
        case 6:
          this->Set(0, 255, 0);
          break;  // Lime
        case 7:
          this->Set(0, 255, 255);
          break;  // Aqua/Cyan
        case 8:
          this->Set(128, 128, 0);
          break;  // Olive
        default:
          this->Set((ChannelType)((rand() * 255) / RAND_MAX), (ChannelType)((rand() * 255) / RAND_MAX),
              (ChannelType)((rand() * 255) / RAND_MAX));
      }
    }
};

// ---------------------------------------------------------------------
#ifdef ENABLE_MP_NAMESPACE
  }// namespace MathPlot
  // No, iff build enables namespace, its up to app to use it appropriately: using namespace MathPlot;
#endif // ENABLE_MP_NAMESPACE

#endif // MATHPLOT_H_INCLUDED