github-starred/pgadmin3
2
0
Fork 0
mirror of https://github.com/levinsv/pgadmin3.git synced 2026-05-15 06:05:49 -06:00
Code Issues 6 Projects Packages Wiki Activity Actions
pgadmin3/include/frm/mathplot.h
lsv 8c123b0550 Add Bar plot 
Добавлена отрисовка столбчатой диаграммы. Формат данных:
L  | Y
------
L1 | Y1
L2 | Y2
...
2022-05-27 22:28:56 +05:00

1899 lines
68 KiB
C++
Raw Permalink Blame History

/////////////////////////////////////////////////////////////////////////////
// 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_
/** @file mathplot.h */
/** @mainpage wxMathPlot
wxMathPlot is a framework for mathematical graph plotting in wxWindows.
The framework is designed for convenience and ease of use.
@section screenshots Screenshots
<a href="http://wxmathplot.sourceforge.net/screenshot.shtml">Go to the
screenshots page.</a>
@section overview Overview
The heart of wxMathPlot is mpWindow, which is a 2D canvas for plot layers.
mpWindow can be embedded as subwindow in a wxPane, a wxFrame, or any other
wxWindow.
mpWindow provides a zoomable and moveable view of the layers. The current
view can
be controlled with the mouse, the scrollbars, and a context menu.
Plot layers are implementations of the abstract base class mpLayer. Those
can
be function plots, scale rulers, or any other vector data visualisation.
wxMathPlot provides two mpLayer implementations for plotting horizontal and
vertical rulers: mpScaleX and mpScaleY.
For convenient function plotting a series of classes derived from mpLayer
are provided, like mpFX, mpProfile, mpLegend and so on. These base classes
already come with plot code, user's own functions can be implemented by
overriding just one member for retrieving a function value.
mpWindow has built-in support for mouse-based pan and zoom through intuitive
combinations of buttons and the mouse wheel. It also incorporates an optional
double buffering mechanism to avoid flicker. Plots can be easily sent to
printer evices or exported in bitmap formats like PNG, BMP or JPEG.
@section coding Coding conventions
wxMathPlot sticks to wxWindow's coding conventions. All entities defined by
wxMathPlot have the prefix <i>mp</i>.
@section author Author and license
wxMathPlot is published under the terms of the wxWindow license.<br>
The original author is David Schalig <mrhill@users.sourceforge.net>.<br>
From June 2007 the project is maintained by Davide Rondini
<cdron77@users.sourceforge.net>.<br>
Authors can be contacted via the wxMathPlot's homepage at
https://sourceforge.net/projects/wxmathplot<br>
Contributors:<br>
Jose Luis Blanco, Val Greene.<br>
*/
// 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
#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;
/** Command IDs used by mpWindow */
enum {
mpID_FIT = 2000, //!< Fit view to match bounding box of all layers
mpID_ZOOM_IN, //!< Zoom into view at clickposition / window center
mpID_ZOOM_OUT, //!< Zoom out
mpID_ZOOM_INX,
mpID_ZOOM_INY,
mpID_ZOOM_OUTX,
mpID_ZOOM_OUTY,
mpID_CENTER, //!< Center view on click position
mpID_LOCKASPECT, //!< Lock x/y scaling aspect
mpID_HELP_MOUSE //!< Shows information about the mouse commands
};
//-----------------------------------------------------------------------------
// mpLayer
//-----------------------------------------------------------------------------
typedef enum __mp_Layer_Type {
mpLAYER_UNDEF, //!< Layer type undefined
mpLAYER_AXIS, //!< Axis type layer
mpLAYER_PLOT, //!< Plot type layer
mpLAYER_INFO, //!< Info box type layer
mpLAYER_BITMAP //!< Bitmap type layer
} mpLayerType;
/** Plot layer, abstract base class.
Any number of mpLayer implementations can be attached to mpWindow.
Examples for mpLayer implementations are function graphs, or scale rulers.
For convenience mpLayer defines a name, a font (wxFont), a pen (wxPen),
and a continuity property (bool) as class members.
The default values at constructor are the default font, a black pen, and
continuity set to false (draw separate points).
These may or may not be used by implementations.
*/
class WXDLLIMPEXP_MATHPLOT mpLayer : public wxObject {
public:
mpLayer();
virtual ~mpLayer(){};
/** Check whether this layer has a bounding box.
The default implementation returns \a TRUE. Override and return
FALSE if your mpLayer implementation should be ignored by the calculation
of the global bounding box for all layers in a mpWindow.
@retval TRUE Has bounding box
@retval FALSE Has not bounding box
*/
virtual bool HasBBox() { return TRUE; }
/** Check whether the layer is an info box.
The default implementation returns \a FALSE. It is overrided to \a TRUE
for mpInfoLayer
class and its derivative. It is necessary to define mouse actions
behaviour over
info boxes.
@return whether the layer is an info boxes
@sa mpInfoLayer::IsInfo */
virtual bool IsInfo() { return false; };
/** Get inclusive left border of bounding box.
@return Value
*/
virtual double GetMinX() { return -1.0; }
/** Get inclusive right border of bounding box.
@return Value
*/
virtual double GetMaxX() { return 1.0; }
/** Get inclusive bottom border of bounding box.
@return Value
*/
virtual double GetMinY() { return -1.0; }
/** Get inclusive top border of bounding box.
@return Value
*/
virtual double GetMaxY() { return 1.0; }
/** Plot given view of layer to the given device context.
An implementation of this function has to transform layer coordinates to
wxDC coordinates based on the view parameters retrievable from the
mpWindow
passed in \a w.
Note that the public methods of mpWindow: x2p,y2p and p2x,p2y are already
provided
which transform layer coordinates to DC pixel coordinates, and <b>user
code should rely
on them</b> for portability and future changes to be applied
transparently, instead of
implementing the following formulas manually.
The passed device context \a dc has its coordinate origin set to the
top-left corner
of the visible area (the default). The coordinate orientation is as shown
in the
following picture:
<pre>
(wxDC origin 0,0)
x-------------> ascending X ----------------+
| |
| |
V ascending Y |
| |
| |
| |
+-------------------------------------------+ <-- right-bottom
corner of the mpWindow visible area.
</pre>
Note that Y ascends in downward direction, whereas the usual vertical
orientation
for mathematical plots is vice versa. Thus Y-orientation will be swapped
usually,
when transforming between wxDC and mpLayer coordinates. This change of
coordinates
is taken into account in the methods p2x,p2y,x2p,y2p.
<b> Rules for transformation between mpLayer and wxDC coordinates </b>
@code
dc_X = (layer_X - mpWindow::GetPosX()) * mpWindow::GetScaleX()
dc_Y = (mpWindow::GetPosY() - layer_Y) * mpWindow::GetScaleY() // swapping
Y-orientation
layer_X = (dc_X / mpWindow::GetScaleX()) + mpWindow::GetPosX() // scale
guaranteed to be not 0
layer_Y = mpWindow::GetPosY() - (dc_Y / mpWindow::GetScaleY()) // swapping
Y-orientation
@endcode
@param dc Device context to plot to.
@param w View to plot. The visible area can be retrieved from this
object.
@sa mpWindow::p2x,mpWindow::p2y,mpWindow::x2p,mpWindow::y2p
*/
virtual void Plot(wxDC &dc, mpWindow &w) = 0;
/** Get layer name.
@return Name
*/
wxString GetName() const { return m_name; }
/** Get font set for this layer.
@return Font
*/
const wxFont &GetFont() const { return m_font; }
/** Get pen set for this layer.
@return Pen
*/
const wxPen &GetPen() const { return m_pen; }
/** Set the 'continuity' property of the layer (true:draws a continuous line,
* false:draws separate points).
* @sa GetContinuity
*/
void SetContinuity(bool continuity) { m_continuous = continuity; }
/** Gets the 'continuity' property of the layer.
* @sa SetContinuity
*/
bool GetContinuity() const { return m_continuous; }
/** Shows or hides the text label with the name of the layer (default is
* visible).
*/
void ShowName(bool show) { m_showName = show; };
/** Set layer name
@param name Name, will be copied to internal class member
*/
void SetName(wxString name) { m_name = name; }
/** Set layer font
@param font Font, will be copied to internal class member
*/
void SetFont(const wxFont &font) { m_font = font; }
/** Set layer pen
@param pen Pen, will be copied to internal class member
*/
void SetPen(const wxPen &pen) { m_pen = pen; }
/** Set Draw mode: inside or outside margins. Default is outside, which allows
the layer to draw up to the mpWindow border.
@param drawModeOutside The draw mode to be set */
void SetDrawOutsideMargins(bool drawModeOutside) {
m_drawOutsideMargins = drawModeOutside;
};
/** Get Draw mode: inside or outside margins.
@return The draw mode */
bool GetDrawOutsideMargins() { return m_drawOutsideMargins; };
/** Get a small square bitmap filled with the colour of the pen used in the
layer. Useful to create legends or similar reference to the layers.
@param side side length in pixels
@return a wxBitmap filled with layer's colour */
wxBitmap GetColourSquare(int side = 16);
/** Get layer type: a Layer can be of different types: plot lines, axis, info
boxes, etc, this method returns the right value.
@return An integer indicating layer type */
mpLayerType GetLayerType() { return m_type; };
/** Checks whether the layer is visible or not.
@return \a true if visible */
bool IsVisible() { return m_visible; };
bool IsSelect() { return m_select; };
void SetSelect(bool select) { m_select = select; };
/** Sets layer visibility.
@param show visibility bool. */
void SetVisible(bool show) { m_visible = show; };
/** Get brush set for this layer.
@return brush. */
const wxBrush &GetBrush() const { return m_brush; };
/** Set layer brush
@param brush brush, will be copied to internal class member */
void SetBrush(wxBrush brush) { m_brush = brush; };
protected:
wxFont m_font; //!< Layer's font
wxPen m_pen; //!< Layer's pen
wxBrush m_brush; //!< Layer's brush
wxString m_name; //!< Layer's name
bool m_continuous; //!< Specify if the layer will be plotted as a continuous
//line or a set of points.
bool m_showName; //!< States whether the name of the layer must be shown
//(default is true).
bool m_drawOutsideMargins; //!< select if the layer should draw only inside
//margins or over all DC
mpLayerType m_type; //!< Define layer type, which is assigned by constructor
bool m_visible; //!< Toggles layer visibility
bool m_select;
DECLARE_DYNAMIC_CLASS(mpLayer)
};
//-----------------------------------------------------------------------------
// mpInfoLayer
//-----------------------------------------------------------------------------
/** @class mpInfoLayer
@brief Base class to create small rectangular info boxes
mpInfoLayer is the base class to create a small rectangular info box in
transparent overlay over plot layers. It is used to implement objects like
legends.
*/
class WXDLLIMPEXP_MATHPLOT mpInfoLayer : public mpLayer {
public:
/** Default constructor. */
mpInfoLayer();
/** Complete constructor.
@param rect Sets the initial size rectangle of the layer.
@param brush pointer to a fill brush. Default is transparent */
mpInfoLayer(wxRect rect, const wxBrush *brush = wxTRANSPARENT_BRUSH);
/** Destructor */
virtual ~mpInfoLayer();
/** Updates the content of the info box. Should be overidden by derived
classes.
Update may behave in different ways according to the type of event which
called it.
@param w parent mpWindow from which to obtain informations
@param event The event which called the update. */
virtual void UpdateInfo(mpWindow &w, wxEvent &event);
/** mpInfoLayer has not bounding box. @sa mpLayer::HasBBox
@return always \a FALSE */
virtual bool HasBBox() { return false; };
/** Plot method. Can be overidden by derived classes.
@param dc the device content where to plot
@param w the window to plot
@sa mpLayer::Plot */
virtual void Plot(wxDC &dc, mpWindow &w);
/** Specifies that this is an Info box layer.
@return always \a TRUE
@sa mpLayer::IsInfo */
virtual bool IsInfo() { return true; };
/** Checks whether a point is inside the info box rectangle.
@param point The point to be checked
@return \a true if the point is inside the bounding box */
virtual bool Inside(wxPoint &point);
/** Moves the layer rectangle of given pixel deltas.
@param delta The wxPoint container for delta coordinates along x and y.
Units are in pixels. */
virtual void Move(wxPoint delta);
/** Updates the rectangle reference point. Used by internal methods of
* mpWindow to correctly move mpInfoLayers. */
virtual void UpdateReference();
/** Returns the position of the upper left corner of the box (in pixels)
@return The rectangle position */
wxPoint GetPosition();
/** Returns the size of the box (in pixels)
@return The rectangle size */
wxSize GetSize();
/** Returns the current rectangle coordinates.
@return The info layer rectangle */
const wxRect &GetRectangle() { return m_dim; };
protected:
wxRect m_dim; //!< The bounding rectangle of the box. It may be resized
//dynamically by the Plot method.
wxPoint m_reference; //!< Holds the reference point for movements
int m_winX, m_winY; //!< Holds the mpWindow size. Used to rescale position
//when window is resized.
DECLARE_DYNAMIC_CLASS(mpInfoLayer)
};
/** @class mpInfoCoords
@brief Implements an overlay box which shows the mouse coordinates in plot
units.
When an mpInfoCoords layer is activated, when mouse is moved over the
mpWindow, its coordinates (in mpWindow units, not pixels) are continuously
reported inside the layer box. */
class WXDLLIMPEXP_MATHPLOT mpInfoCoords : public mpInfoLayer {
public:
/** Default constructor */
mpInfoCoords();
/** Complete constructor, setting initial rectangle and background brush.
@param rect The initial bounding rectangle.
@param brush The wxBrush to be used for box background: default is
transparent */
mpInfoCoords(wxRect rect, const wxBrush *brush = wxTRANSPARENT_BRUSH);
/** Default destructor */
~mpInfoCoords();
/** Updates the content of the info box. It is used to update coordinates.
@param w parent mpWindow from which to obtain information
@param event The event which called the update. */
virtual void UpdateInfo(mpWindow &w, wxEvent &event);
/** Plot method.
@param dc the device content where to plot
@param w the window to plot
@sa mpLayer::Plot */
virtual void Plot(wxDC &dc, mpWindow &w);
protected:
wxString m_content; //!< string holding the coordinates to be drawn.
double lastx, lasty;
};
/** @class mpInfoLegend
@brief Implements the legend to be added to the plot
This layer allows you to add a legend to describe the plots in the window.
The legend uses the layer name as a label, and displays only layers of type
mpLAYER_PLOT. */
class WXDLLIMPEXP_MATHPLOT mpInfoLegend : public mpInfoLayer {
public:
/** Default constructor */
mpInfoLegend();
/** Complete constructor, setting initial rectangle and background brush.
@param rect The initial bounding rectangle.
@param brush The wxBrush to be used for box background: default is
transparent
@sa mpInfoLayer::mpInfoLayer */
mpInfoLegend(wxRect rect, const wxBrush *brush = wxTRANSPARENT_BRUSH);
/** Default destructor */
~mpInfoLegend();
/** Updates the content of the info box. Unused in this class.
@param w parent mpWindow from which to obtain information
@param event The event which called the update. */
virtual void UpdateInfo(mpWindow &w, wxEvent &event);
/** Plot method.
@param dc the device content where to plot
@param w the window to plot
@sa mpLayer::Plot */
virtual void Plot(wxDC &dc, mpWindow &w);
protected:
wxPoint m_mouse_point;
};
//-----------------------------------------------------------------------------
// mpLayer implementations - functions
//-----------------------------------------------------------------------------
/** @name Label alignment constants
@{*/
/** @internal */
#define mpALIGNMASK 0x03
/** Aligns label to the right. For use with mpFX. */
#define mpALIGN_RIGHT 0x00
/** Aligns label to the center. For use with mpFX and mpFY. */
#define mpALIGN_CENTER 0x01
/** Aligns label to the left. For use with mpFX. */
#define mpALIGN_LEFT 0x02
/** Aligns label to the top. For use with mpFY. */
#define mpALIGN_TOP mpALIGN_RIGHT
/** Aligns label to the bottom. For use with mpFY. */
#define mpALIGN_BOTTOM mpALIGN_LEFT
/** Aligns X axis to bottom border. For mpScaleX */
#define mpALIGN_BORDER_BOTTOM 0x04
/** Aligns X axis to top border. For mpScaleX */
#define mpALIGN_BORDER_TOP 0x05
/** Set label for X axis in normal mode */
#define mpX_NORMAL 0x00
/** Set label for X axis in time mode: the value is represented as
* minutes:seconds.milliseconds if time is less than 2 minutes,
* hours:minutes:seconds otherwise. */
#define mpX_TIME 0x01
/** Set label for X axis in hours mode: the value is always represented as
* hours:minutes:seconds. */
#define mpX_HOURS 0x02
/** Set label for X axis in date mode: the value is always represented as
* yyyy-mm-dd. */
#define mpX_DATE 0x03
/** Set label for X axis in datetime mode: the value is always represented as
* yyyy-mm-ddThh:mm:ss. */
#define mpX_DATETIME 0x04
/** Aligns Y axis to left border. For mpScaleY */
#define mpALIGN_BORDER_LEFT mpALIGN_BORDER_BOTTOM
/** Aligns Y axis to right border. For mpScaleY */
#define mpALIGN_BORDER_RIGHT mpALIGN_BORDER_TOP
/** Aligns label to north-east. For use with mpFXY. */
#define mpALIGN_NE 0x00
/** Aligns label to north-west. For use with mpFXY. */
#define mpALIGN_NW 0x01
/** Aligns label to south-west. For use with mpFXY. */
#define mpALIGN_SW 0x02
/** Aligns label to south-east. For use with mpFXY. */
#define mpALIGN_SE 0x03
/*@}*/
/** @name mpLayer implementations - functions
@{*/
/** Abstract base class providing plot and labeling functionality for functions
F:X->Y.
Override mpFX::GetY to implement a function.
Optionally implement a constructor and pass a name (label) and a label
alignment
to the constructor mpFX::mpFX. If the layer name is empty, no label will be
plotted.
*/
class WXDLLIMPEXP_MATHPLOT mpFX : public mpLayer {
public:
/** @param name Label
@param flags Label alignment, pass one of #mpALIGN_RIGHT, #mpALIGN_CENTER,
#mpALIGN_LEFT.
*/
mpFX(wxString name = wxEmptyString, int flags = mpALIGN_RIGHT);
/** Get function value for argument.
Override this function in your implementation.
@param x Argument
@return Function value
*/
virtual double GetY(double x) = 0;
/** Layer plot handler.
This implementation will plot the function in the visible area and
put a label according to the aligment specified.
*/
virtual void Plot(wxDC &dc, mpWindow &w);
protected:
int m_flags; //!< Holds label alignment
DECLARE_DYNAMIC_CLASS(mpFX)
};
/** Abstract base class providing plot and labeling functionality for functions
F:Y->X.
Override mpFY::GetX to implement a function.
Optionally implement a constructor and pass a name (label) and a label
alignment
to the constructor mpFY::mpFY. If the layer name is empty, no label will be
plotted.
*/
class WXDLLIMPEXP_MATHPLOT mpFY : public mpLayer {
public:
/** @param name Label
@param flags Label alignment, pass one of #mpALIGN_BOTTOM,
#mpALIGN_CENTER, #mpALIGN_TOP.
*/
mpFY(wxString name = wxEmptyString, int flags = mpALIGN_TOP);
/** Get function value for argument.
Override this function in your implementation.
@param y Argument
@return Function value
*/
virtual double GetX(double y) = 0;
/** Layer plot handler.
This implementation will plot the function in the visible area and
put a label according to the aligment specified.
*/
virtual void Plot(wxDC &dc, mpWindow &w);
protected:
int m_flags; //!< Holds label alignment
DECLARE_DYNAMIC_CLASS(mpFY)
};
/** Abstract base class providing plot and labeling functionality for a locus
plot F:N->X,Y.
Locus argument N is assumed to be in range 0 .. MAX_N, and implicitly
derived by enumerating
all locus values. Override mpFXY::Rewind and mpFXY::GetNextXY to implement a
locus.
Optionally implement a constructor and pass a name (label) and a label
alignment
to the constructor mpFXY::mpFXY. If the layer name is empty, no label will
be plotted.
*/
class WXDLLIMPEXP_MATHPLOT mpFXY : public mpLayer {
public:
/** @param name Label
@param flags Label alignment, pass one of #mpALIGN_NE, #mpALIGN_NW,
#mpALIGN_SW, #mpALIGN_SE.
*/
mpFXY(wxString name = wxEmptyString, int flags = mpALIGN_NE);
/** Rewind value enumeration with mpFXY::GetNextXY.
Override this function in your implementation.
*/
virtual void Rewind() = 0;
/** Get locus value for next N.
Override this function in your implementation.
@param x Returns X value
@param y Returns Y value
*/
virtual bool GetNextXY(double &x, double &y) = 0;
/** Get legend value for N.
Override this function in your implementation.
@param x Returns X value
@param y Returns Y value
*/
virtual wxString GetLegendBar() = 0;
/** Layer plot handler.
This implementation will plot the locus in the visible area and
put a label according to the alignment specified.
*/
virtual void Plot(wxDC &dc, mpWindow &w);
/*
Show simbol point
*/
virtual void ShowSimbol(bool isShow) { m_simbol=isShow;};
protected:
int m_flags; //!< Holds label alignment
bool m_simbol;
// Data to calculate label positioning
wxCoord maxDrawX, minDrawX, maxDrawY, minDrawY;
// int drawnPoints;
/** Update label positioning data
@param xnew New x coordinate
@param ynew New y coordinate
*/
void UpdateViewBoundary(wxCoord xnew, wxCoord ynew);
DECLARE_DYNAMIC_CLASS(mpFXY)
};
/** Abstract base class providing plot and labeling functionality for functions
F:Y->X.
Override mpProfile::GetX to implement a function.
This class is similar to mpFY, but the Plot method is different. The plot is
in fact represented by lines instead of points, which gives best rendering of
rapidly-varying functions, and in general, data which are not so close one to
another.
Optionally implement a constructor and pass a name (label) and a label
alignment
to the constructor mpProfile::mpProfile. If the layer name is empty, no
label will be plotted.
*/
class WXDLLIMPEXP_MATHPLOT mpProfile : public mpLayer {
public:
/** @param name Label
@param flags Label alignment, pass one of #mpALIGN_BOTTOM,
#mpALIGN_CENTER, #mpALIGN_TOP.
*/
mpProfile(wxString name = wxEmptyString, int flags = mpALIGN_TOP);
/** Get function value for argument.
Override this function in your implementation.
@param x Argument
@return Function value
*/
virtual double GetY(double x) = 0;
/** Layer plot handler.
This implementation will plot the function in the visible area and
put a label according to the aligment specified.
*/
virtual void Plot(wxDC &dc, mpWindow &w);
protected:
int m_flags; //!< Holds label alignment
DECLARE_DYNAMIC_CLASS(mpProfile)
};
/*@}*/
//-----------------------------------------------------------------------------
// mpLayer implementations - furniture (scales, ...)
//-----------------------------------------------------------------------------
/** @name mpLayer implementations - furniture (scales, ...)
@{*/
/** Plot layer implementing a x-scale ruler.
The ruler is fixed at Y=0 in the coordinate system. A label is plotted at
the bottom-right hand of the ruler. The scale numbering automatically
adjusts to view and zoom factor.
*/
class WXDLLIMPEXP_MATHPLOT mpScaleX : public mpLayer {
public:
/** Full constructor.
@param name Label to plot by the ruler
@param flags Set the position of the scale with respect to the
window.
@param ticks Select ticks or grid. Give TRUE (default) for drawing
axis ticks, FALSE for drawing the grid.
@param type mpX_NORMAL for normal labels, mpX_TIME for time axis
in hours, minutes, seconds. */
mpScaleX(wxString name = wxT("X"), int flags = mpALIGN_CENTER,
bool ticks = true, unsigned int type = mpX_NORMAL);
/** Layer plot handler.
This implementation will plot the ruler adjusted to the visible area. */
virtual void Plot(wxDC &dc, mpWindow &w);
// Get text label for value
virtual wxString GetLabelTextValue(double &v);
/** Check whether this layer has a bounding box.
This implementation returns \a FALSE thus making the ruler invisible
to the plot layer bounding box calculation by mpWindow. */
virtual bool HasBBox() { return FALSE; }
/** Set X axis alignment.
@param align alignment (choose between mpALIGN_BORDER_BOTTOM,
mpALIGN_BOTTOM, mpALIGN_CENTER, mpALIGN_TOP, mpALIGN_BORDER_TOP */
void SetAlign(int align) { m_flags = align; };
/** Set X axis ticks or grid
@param ticks TRUE to plot axis ticks, FALSE to plot grid. */
void SetTicks(bool ticks) { m_ticks = ticks; };
/** Get X axis ticks or grid
@return TRUE if plot is drawing axis ticks, FALSE if the grid is active.
*/
bool GetTicks() { return m_ticks; };
/** Get X axis label view mode.
@return mpX_NORMAL for normal labels, mpX_TIME for time axis in hours,
minutes, seconds. */
unsigned int GetLabelMode() { return m_labelType; };
/** Set X axis label view mode.
@param mode mpX_NORMAL for normal labels, mpX_TIME for time axis in hours,
minutes, seconds. */
void SetLabelMode(unsigned int mode) { m_labelType = mode; };
/** Set X axis Label format (used for mpX_NORMAL draw mode).
@param format The format string */
void SetLabelFormat(const wxString &format) { m_labelFormat = format; };
/** Get X axis Label format (used for mpX_NORMAL draw mode).
@return The format string */
const wxString &SetLabelFormat() { return m_labelFormat; };
protected:
int m_flags; //!< Flag for axis alignment
bool m_ticks; //!< Flag to toggle between ticks or grid
unsigned int m_labelType; //!< Select labels mode: mpX_NORMAL for normal
//labels, mpX_TIME for time axis in hours, minutes,
//seconds
wxString m_labelFormat; //!< Format string used to print labels
DECLARE_DYNAMIC_CLASS(mpScaleX)
};
/** Plot layer implementing a y-scale ruler.
If align is set to mpALIGN_CENTER, the ruler is fixed at X=0 in the
coordinate system. If the align is set to mpALIGN_TOP or mpALIGN_BOTTOM, the
axis is always drawn respectively at top or bottom of the window. A label is
plotted at
the top-right hand of the ruler. The scale numbering automatically
adjusts to view and zoom factor.
*/
class WXDLLIMPEXP_MATHPLOT mpScaleY : public mpLayer {
public:
/** @param name Label to plot by the ruler
@param flags Set position of the scale respect to the window.
@param ticks Select ticks or grid. Give TRUE (default) for drawing axis
ticks, FALSE for drawing the grid */
mpScaleY(wxString name = wxT("Y"), int flags = mpALIGN_CENTER,
bool ticks = true);
/** Layer plot handler.
This implementation will plot the ruler adjusted to the visible area.
*/
virtual void Plot(wxDC &dc, mpWindow &w);
/** Check whether this layer has a bounding box.
This implementation returns \a FALSE thus making the ruler invisible
to the plot layer bounding box calculation by mpWindow.
*/
virtual bool HasBBox() { return FALSE; }
/** Set Y axis alignment.
@param align alignment (choose between mpALIGN_BORDER_LEFT, mpALIGN_LEFT,
mpALIGN_CENTER, mpALIGN_RIGHT, mpALIGN_BORDER_RIGHT) */
void SetAlign(int align) { m_flags = align; };
/** Set Y axis ticks or grid
@param ticks TRUE to plot axis ticks, FALSE to plot grid. */
void SetTicks(bool ticks) { m_ticks = ticks; };
/** Get Y axis ticks or grid
@return TRUE if plot is drawing axis ticks, FALSE if the grid is active.
*/
bool GetTicks() { return m_ticks; };
/** Set Y axis Label format.
@param format The format string */
void SetLabelFormat(const wxString &format) { m_labelFormat = format; };
/** Get Y axis Label format.
@return The format string */
const wxString &SetLabelFormat() { return m_labelFormat; };
protected:
int m_flags; //!< Flag for axis alignment
bool m_ticks; //!< Flag to toggle between ticks or grid
wxString m_labelFormat; //!< Format string used to print labels
DECLARE_DYNAMIC_CLASS(mpScaleY)
};
//-----------------------------------------------------------------------------
// mpWindow
//-----------------------------------------------------------------------------
/** @name Constants defining mouse modes for mpWindow
@{*/
/** Mouse panning drags the view. Mouse mode for mpWindow. */
#define mpMOUSEMODE_DRAG 0
/** Mouse panning creates a zoom box. Mouse mode for mpWindow. */
#define mpMOUSEMODE_ZOOMBOX 1
/*@}*/
/** Define the type for the list of layers inside mpWindow */
// WX_DECLARE_HASH_MAP( int, mpLayer*, wxIntegerHash, wxIntegerEqual,
// wxLayerList );
typedef std::deque<mpLayer *> wxLayerList;
/** Canvas for plotting mpLayer implementations.
This class defines a zoomable and moveable 2D plot canvas. Any number
of mpLayer implementations (scale rulers, function plots, ...) can be
attached using mpWindow::AddLayer.
The canvas window provides a context menu with actions for navigating the
view.
The context menu can be retrieved with mpWindow::GetPopupMenu, e.g. for
extending it
externally.
Since wxMathPlot version 0.03, the mpWindow incorporates the following
features:
- DoubleBuffering (Default=disabled): Can be set with EnableDoubleBuffer
- Mouse based pan/zoom (Default=enabled): Can be set with
EnableMousePanZoom.
The mouse commands can be visualized by the user through the popup menu, and
are:
- Mouse Move+CTRL: Pan (Move)
- Mouse Wheel: Vertical scroll
- Mouse Wheel+SHIFT: Horizontal scroll
- Mouse Wheel UP+CTRL: Zoom in
- Mouse Wheel DOWN+CTRL: Zoom out
*/
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();
/** Get reference to context menu of the plot canvas.
@return Pointer to menu. The menu can be modified.
*/
wxMenu *GetPopupMenu() { return &m_popmenu; }
/** Add a plot layer to the canvas.
@param layer Pointer to layer. The mpLayer object will get under control
of mpWindow,
i.e. it will be delete'd on mpWindow destruction
@param refreshDisplay States whether to refresh the display (UpdateAll)
after adding the layer.
@retval TRUE Success
@retval FALSE Failure due to out of memory.
*/
bool AddLayer(mpLayer *layer, bool refreshDisplay = true);
/** Remove a plot layer from the canvas.
@param layer Pointer to layer. The mpLayer object will be destructed using
delete.
@param alsoDeleteObject If set to true, the mpLayer object will be also
"deleted", not just removed from the internal list.
@param refreshDisplay States whether to refresh the display (UpdateAll)
after removing the layer.
@return true if layer is deleted correctly
N.B. Only the layer reference in the mpWindow is deleted, the layer object
still exists!
*/
bool DelLayer(mpLayer *layer, bool alsoDeleteObject = false,
bool refreshDisplay = true);
/** Remove all layers from the plot.
@param alsoDeleteObject If set to true, the mpLayer objects will be also
"deleted", not just removed from the internal list.
@param refreshDisplay States whether to refresh the display (UpdateAll)
after removing the layers.
*/
void DelAllLayers(bool alsoDeleteObject, bool refreshDisplay = true);
/*! Get the layer in list position indicated.
N.B. You <i>must</i> know the index of the layer inside the list!
@param position position of the layer in the layers list
@return pointer to mpLayer
*/
mpLayer *GetLayer(int position);
/*! Get the layer by its name (case sensitive).
@param name The name of the layer to retrieve
@return A pointer to the mpLayer object, or NULL if not found.
*/
mpLayer *GetLayerByName(const wxString &name);
/** Get current view's X scale.
See @ref mpLayer::Plot "rules for coordinate transformation"
@return Scale
*/
double GetXscl() { return m_scaleX; }
double GetScaleX(void) const {
return m_scaleX;
}; // Schaling's method: maybe another method esists with the same name
/** Get current view's Y scale.
See @ref mpLayer::Plot "rules for coordinate transformation"
@return Scale
*/
double GetYscl() const { return m_scaleY; }
double GetScaleY(void) const {
return m_scaleY;
} // Schaling's method: maybe another method exists with the same name
/** Get current view's X position.
See @ref mpLayer::Plot "rules for coordinate transformation"
@return X Position in layer coordinate system, that corresponds to the
center point of the view.
*/
double GetXpos() const { return m_posX; }
double GetPosX(void) const { return m_posX; }
/** Get current view's Y position.
See @ref mpLayer::Plot "rules for coordinate transformation"
@return Y Position in layer coordinate system, that corresponds to the
center point of the view.
*/
double GetYpos() const { return m_posY; }
double GetPosY(void) const { return m_posY; }
/** Get current view's X dimension in device context units.
Usually this is equal to wxDC::GetSize, but it might differ thus mpLayer
implementations should rely on the value returned by the function.
See @ref mpLayer::Plot "rules for coordinate transformation"
@return X dimension.
*/
int GetScrX(void) const { return m_scrX; }
int GetXScreen(void) const { return m_scrX; }
/** Get current view's Y dimension in device context units.
Usually this is equal to wxDC::GetSize, but it might differ thus mpLayer
implementations should rely on the value returned by the function.
See @ref mpLayer::Plot "rules for coordinate transformation"
@return Y dimension.
*/
int GetScrY(void) const { return m_scrY; }
int GetYScreen(void) const { return m_scrY; }
/** Set current view's X scale and refresh display.
@param scaleX New scale, must not be 0.
*/
void SetScaleX(double scaleX);
/** Set current view's Y scale and refresh display.
@param scaleY New scale, must not be 0.
*/
void SetScaleY(double scaleY) {
if (scaleY != 0)
m_scaleY = scaleY;
UpdateAll();
}
/** Set current view's X position and refresh display.
@param posX New position that corresponds to the center point of the view.
*/
void SetPosX(double posX) {
m_posX = posX;
UpdateAll();
}
/** Set current view's Y position and refresh display.
@param posY New position that corresponds to the center point of the view.
*/
void SetPosY(double posY) {
m_posY = posY;
UpdateAll();
}
/** Set current view's X and Y position and refresh display.
@param posX New position that corresponds to the center point of the view.
@param posY New position that corresponds to the center point of the view.
*/
void SetPos(double posX, double posY) {
m_posX = posX;
m_posY = posY;
UpdateAll();
}
/** Set current view's dimensions in device context units.
Needed by plotting functions. It doesn't refresh display.
@param scrX New position that corresponds to the center point of the view.
@param scrY New position that corresponds to the center point of the view.
*/
void SetScr(int scrX, int scrY) {
m_scrX = scrX;
m_scrY = scrY;
}
/** Converts mpWindow (screen) pixel coordinates into graph (floating point)
* coordinates, using current mpWindow position and scale.
* @sa p2y,x2p,y2p */
// double p2x(wxCoord pixelCoordX, bool drawOutside = true ); // { return
// m_posX + pixelCoordX/m_scaleX; }
inline double p2x(wxCoord pixelCoordX) {
return m_posX + pixelCoordX / m_scaleX;
}
/** Converts mpWindow (screen) pixel coordinates into graph (floating point)
* coordinates, using current mpWindow position and scale.
* @sa p2x,x2p,y2p */
// double p2y(wxCoord pixelCoordY, bool drawOutside = true ); //{ return
// m_posY - pixelCoordY/m_scaleY; }
inline double p2y(wxCoord pixelCoordY) {
return m_posY - pixelCoordY / m_scaleY;
}
/** Converts graph (floating point) coordinates into mpWindow (screen) pixel
* coordinates, using current mpWindow position and scale.
* @sa p2x,p2y,y2p */
// 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); }
/** Converts graph (floating point) coordinates into mpWindow (screen) pixel
* coordinates, using current mpWindow position and scale.
* @sa p2x,p2y,x2p */
// 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); }
/** Enable/disable the feature of pan/zoom with the mouse (default=enabled)
*/
void EnableMousePanZoom(bool enabled) { m_enableMouseNavigation = enabled; }
/** Enable or disable X/Y scale aspect locking for the view.
@note Explicit calls to mpWindow::SetScaleX and mpWindow::SetScaleY will
set
an unlocked aspect, but any other action changing the view scale
will
lock the aspect again.
*/
void LockAspect(bool enable = TRUE);
/** Checks whether the X/Y scale aspect is locked.
@retval TRUE Locked
@retval FALSE Unlocked
*/
inline bool IsAspectLocked() { return m_lockaspect; }
/** Set view to fit global bounding box of all plot layers and refresh
display.
Scale and position will be set to show all attached mpLayers.
The X/Y scale aspect lock is taken into account.
*/
void Fit();
/** Set view to fit a given bounding box and refresh display.
The X/Y scale aspect lock is taken into account.
If provided, the parameters printSizeX and printSizeY are taken as the DC
size, and the
pixel scales are computed accordingly. Also, in this case the passed
borders are not saved
as the "desired borders", since this use will be invoked only when
printing.
*/
void Fit(double xMin, double xMax, double yMin, double yMax,
wxCoord *printSizeX = NULL, wxCoord *printSizeY = NULL);
/** Zoom into current view and refresh display
* @param centerPoint The point (pixel coordinates) that will stay in the
* same position on the screen after the zoom (by default, the center of the
* mpWindow).
*/
void ZoomIn(const wxPoint &centerPoint = wxDefaultPosition);
/** Zoom out current view and refresh display
* @param centerPoint The point (pixel coordinates) that will stay in the
* same position on the screen after the zoom (by default, the center of the
* mpWindow).
*/
void ZoomOut(const wxPoint &centerPoint = wxDefaultPosition);
/** Zoom in current view along X and refresh display */
void ZoomInX();
/** Zoom out current view along X and refresh display */
void ZoomOutX();
/** Zoom in current view along Y and refresh display */
void ZoomInY();
/** Zoom out current view along Y and refresh display */
void ZoomOutY();
/** Zoom view fitting given coordinates to the window (p0 and p1 do not need
* to be in any specific order) */
void ZoomRect(wxPoint p0, wxPoint p1);
/** Refresh display */
void UpdateAll();
// Added methods by Davide Rondini
/** Counts the number of plot layers, excluding axes or text: this is to count
only the layers which have a bounding box.
\return The number of profiles plotted.
*/
unsigned int CountLayers();
/** Counts the number of plot layers, whether or not they have a bounding box.
\return The number of layers in the mpWindow. */
unsigned int CountAllLayers() { return m_layers.size(); };
/** Draws the mpWindow on a page for printing
\param print the mpPrintout where to print the graph */
// void PrintGraph(mpPrintout *print);
/** Returns the left-border layer coordinate that the user wants the mpWindow
* to show (it may be not exactly the actual shown coordinate in the case of
* locked aspect ratio).
* @sa Fit
*/
double GetDesiredXmin() { return m_desiredXmin; }
/** Returns the right-border layer coordinate that the user wants the mpWindow
* to show (it may be not exactly the actual shown coordinate in the case of
* locked aspect ratio).
* @sa Fit
*/
double GetDesiredXmax() { return m_desiredXmax; }
/** Returns the bottom-border layer coordinate that the user wants the
* mpWindow to show (it may be not exactly the actual shown coordinate in the
* case of locked aspect ratio).
* @sa Fit
*/
double GetDesiredYmin() { return m_desiredYmin; }
/** Returns the top layer-border coordinate that the user wants the mpWindow
* to show (it may be not exactly the actual shown coordinate in the case of
* locked aspect ratio).
* @sa Fit
*/
double GetDesiredYmax() { return m_desiredYmax; }
/** Returns the bounding box coordinates
@param bbox Pointer to a 6-element double array where to store
bounding box coordinates. */
void GetBoundingBox(double *bbox);
/** Enable/disable scrollbars
@param status Set to true to show scrollbars */
void SetMPScrollbars(bool status);
/** Get scrollbars status.
@return true if scrollbars are visible */
bool GetMPScrollbars() { return m_enableScrollBars; };
/** Draw the window on a wxBitmap, then save it to a file.
@param filename File name where to save the screenshot
@param type image type to be saved: see wxImage output file types for flags
@param imageSize Set a size for the output image. Default is the same as
the screen size
@param fit Decide whether to fit the plot into the size*/
bool SaveScreenshot(const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_BMP,
wxSize imageSize = wxDefaultSize, bool fit = false,bool copyboard=false);
/** This value sets the zoom steps whenever the user clicks "Zoom in/out" or
* performs zoom with the mouse wheel.
* It must be a number above unity. This number is used for zoom in, and its
* inverse for zoom out. Set to 1.5 by default. */
static double zoomIncrementalFactor;
/** Set window margins, creating a blank area where some kinds of layers
cannot draw. This is useful for example to draw axes outside the area where
the plots are drawn.
@param top Top border
@param right Right border
@param bottom Bottom border
@param left Left border */
void SetMargins(int top, int right, int bottom, int left);
/** Set the top margin. @param top Top Margin */
void SetMarginTop(int top) { m_marginTop = top; };
/** Set the right margin. @param right Right Margin */
void SetMarginRight(int right) { m_marginRight = right; };
/** Set the bottom margin. @param bottom Bottom Margin */
void SetMarginBottom(int bottom) { m_marginBottom = bottom; };
/** Set the left margin. @param left Left Margin */
void SetMarginLeft(int left) { m_marginLeft = left; };
/** Get the top margin. @param top Top Margin */
int GetMarginTop() { return m_marginTop; };
/** Get the right margin. @param right Right Margin */
int GetMarginRight() { return m_marginRight; };
/** Get the bottom margin. @param bottom Bottom Margin */
int GetMarginBottom() { return m_marginBottom; };
/** Get the left margin. @param left Left Margin */
int GetMarginLeft() { return m_marginLeft; };
/** Sets whether to show coordinate tooltip when mouse passes over the plot.
* \param value true for enable, false for disable */
// void EnableCoordTooltip(bool value = true);
/** Gets coordinate tooltip status. \return true for enable, false for disable
*/
// bool GetCoordTooltip() { return m_coordTooltip; };
/** Check if a given point is inside the area of a mpInfoLayer and eventually
returns its pointer.
@param point The position to be checked
@return If an info layer is found, returns its pointer, NULL otherwise */
mpInfoLayer *IsInsideInfoLayer(wxPoint &point);
/** Sets the visibility of a layer by its name.
@param name The layer name to set visibility
@param viewable the view status to be set */
void SetLayerVisible(const wxString &name, bool viewable);
/** Check whether a layer with given name is visible
@param name The layer name
@return layer visibility status */
bool IsLayerVisible(const wxString &name);
/** Sets the visibility of a layer by its position in layer list.
@param position The layer position in layer list
@param viewable the view status to be set */
void SetLayerVisible(const unsigned int position, bool viewable);
/** Check whether the layer at given position is visible
@param position The layer position in layer list
@return layer visibility status */
bool IsLayerVisible(const unsigned int position);
/** Set Color theme. Provide colours to set a new colour theme.
@param bgColour Background colour
@param drawColour The colour used to draw all elements in foreground,
axes excluded
@param axesColour The colour used to draw axes (but not their labels)*/
void SetColourTheme(const wxColour &bgColour, const wxColour &drawColour,
const wxColour &axesColour);
/** Get axes draw colour
@return reference to axis colour used in theme */
const wxColour &GetAxesColour() { return m_axColour; };
void OnCenter(wxCommandEvent& event); //!< Context menu handler
void OnFit(wxCommandEvent& event); //!< Context menu handler
void OnZoomIn(wxCommandEvent& event); //!< Context menu handler
void OnZoomOut(wxCommandEvent& event); //!< Context menu handler
void OnZoomInX(wxCommandEvent& WXUNUSED(event));
void OnZoomInY(wxCommandEvent& WXUNUSED(event));
void OnZoomOutX(wxCommandEvent& WXUNUSED(event));
void OnZoomOutY(wxCommandEvent& WXUNUSED(event));
void OnScrollThumbTrack(
wxScrollWinEvent& event); //!< Scroll thumb on scroll bar moving
void OnLockAspect(wxCommandEvent& event); //!< Context menu handler
protected:
void OnPaint(
wxPaintEvent &event); //!< Paint handler, will plot all attached layers
void
OnSize(wxSizeEvent &event); //!< Size handler, will update scroll bar sizes
// void OnScroll2 (wxScrollWinEvent &event); //!< Scroll handler, will
// move canvas
void OnShowPopupMenu(
wxMouseEvent &event); //!< Mouse handler, will show context menu
void OnMouseRightDown(wxMouseEvent &event); //!< Mouse handler, for detecting
//when the user drags with the
//right button or just "clicks"
//for the menu
void OnMouseHelp(wxCommandEvent &event); //!< Context menu handler
void OnMouseWheel(wxMouseEvent &event); //!< Mouse handler for the wheel
void OnMouseMove(
wxMouseEvent &event); //!< Mouse handler for mouse motion (for pan)
void
OnMouseLeftDown(wxMouseEvent &event); //!< Mouse left click (for rect zoom)
void
OnMouseLeftRelease(wxMouseEvent &event); //!< Mouse left click (for rect zoom)
void OnScrollPageUp(wxScrollWinEvent &event); //!< Scroll page up
void OnScrollPageDown(wxScrollWinEvent &event); //!< Scroll page down
void OnScrollLineUp(wxScrollWinEvent &event); //!< Scroll line up
void OnScrollLineDown(wxScrollWinEvent &event); //!< Scroll line down
void OnScrollTop(wxScrollWinEvent &event); //!< Scroll to top
void OnScrollBottom(wxScrollWinEvent &event); //!< Scroll to bottom
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);
/** Recalculate global layer bounding box, and save it in m_minX,...
* \return true if there is any valid BBox information.
*/
virtual bool UpdateBBox();
// wxList m_layers; //!< List of attached plot layers
wxLayerList m_layers; //!< List of attached plot layers
wxMenu m_popmenu; //!< Canvas' context menu
bool m_lockaspect; //!< Scale aspect is locked or not
// bool m_coordTooltip; //!< Selects whether to show coordinate tooltip
wxColour m_bgColour; //!< Background Colour
wxColour m_fgColour; //!< Foreground Colour
wxColour m_axColour; //!< Axes Colour
double m_minX; //!< Global layer bounding box, left border incl.
double m_maxX; //!< Global layer bounding box, right border incl.
double m_minY; //!< Global layer bounding box, bottom border incl.
double m_maxY; //!< Global layer bounding box, top border incl.
double m_scaleX; //!< Current view's X scale
double m_scaleY; //!< Current view's Y scale
double m_posX; //!< Current view's X position
double m_posY; //!< Current view's Y position
int m_scrX; //!< Current view's X dimension
int m_scrY; //!< Current view's Y dimension
int m_clickedX; //!< Last mouse click X position, for centering and zooming
//the view
int m_clickedY; //!< Last mouse click Y position, for centering and zooming
//the view
/** These are updated in Fit() only, and may be different from the real
* borders (layer coordinates) only if lock aspect ratio is true.
*/
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; //!< For double buffering
wxMemoryDC m_buff_dc; //!< For double buffering
wxBitmap *m_buff_bmp; //!< For double buffering
bool m_enableMouseNavigation; //!< For pan/zoom with the mouse.
bool m_mouseMovedAfterRightClick;
long m_mouseRClick_X,
m_mouseRClick_Y; //!< For the right button "drag" feature
int m_mouseLClick_X,
m_mouseLClick_Y; //!< Starting coords for rectangular zoom selection
bool m_enableScrollBars;
int m_scrollX, m_scrollY;
mpInfoLayer *
m_movingInfoLayer; //!< For moving info layers over the window area
DECLARE_DYNAMIC_CLASS(mpWindow)
DECLARE_EVENT_TABLE()
};
//-----------------------------------------------------------------------------
// mpFXYVector - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
/** A class providing graphs functionality for a 2D plot (either continuous or a
set of points), from vectors of data.
This class can be used directly, the user does not need to derive any new
class. Simply pass the data as two vectors
with the same length containing the X and Y coordinates to the method
SetData.
To generate a graph with a set of points, call
\code
layerVar->SetContinuity(false)
\endcode
or
\code
layerVar->SetContinuity(true)
\endcode
to render the sequence of coordinates as a continuous line.
(Added: Jose Luis Blanco, AGO-2007)
*/
class WXDLLIMPEXP_MATHPLOT mpFXYVector : public mpFXY {
public:
/** @param name Label
@param flags Label alignment, pass one of #mpALIGN_NE, #mpALIGN_NW,
#mpALIGN_SW, #mpALIGN_SE.
*/
mpFXYVector(wxString name = wxEmptyString, int flags = mpALIGN_NE);
/** Changes the internal data: the set of points to draw.
Both vectors MUST be of the same length. This method DOES NOT refresh the
mpWindow; do it manually.
* @sa Clear
*/
void SetData(const std::vector<double> &xs, const std::vector<double> &ys);
void SetLegendBar(const std::vector<wxString>& leg);
bool IsLegendBar() { return m_leg.size() > 0; }
wxString GetLegendBar() {
return m_current_leg
;
}
/** Clears all the data, leaving the layer empty.
* @sa SetData
*/
void Clear();
double GetDistance(double &x,double &y);
int GetSize();
protected:
/** The internal copy of the set of data to draw.
*/
std::vector<double> m_xs, m_ys;
std::vector<wxString> m_leg;
wxString m_current_leg;
/** The internal counter for the "GetNextXY" interface
*/
size_t m_index;
/** Loaded at SetData
*/
double m_minX, m_maxX, m_minY, m_maxY;
/** Rewind value enumeration with mpFXY::GetNextXY.
Overridden in this implementation.
*/
void Rewind();
/** Get locus value for next N.
Overridden in this implementation.
@param x Returns X value
@param y Returns Y value
*/
bool GetNextXY(double &x, double &y);
/** Returns the actual minimum X data (loaded in SetData).
*/
double GetMinX() { return m_minX; }
/** Returns the actual minimum Y data (loaded in SetData).
*/
double GetMinY() { return m_minY; }
/** Returns the actual maximum X data (loaded in SetData).
*/
double GetMaxX() { return m_maxX; }
/** Returns the actual maximum Y data (loaded in SetData).
*/
double GetMaxY() { return m_maxY; }
int m_flags; //!< Holds label alignment
DECLARE_DYNAMIC_CLASS(mpFXYVector)
};
//-----------------------------------------------------------------------------
// mpText - provided by Val Greene
//-----------------------------------------------------------------------------
/** Plot layer implementing a text string.
The text is plotted using a percentage system 0-100%, so the actual
coordinates for the location are not required, and the text stays
on the plot reguardless of the other layers location and scaling
factors.
*/
class WXDLLIMPEXP_MATHPLOT mpText : public mpLayer {
public:
/** @param name text to be drawn in the plot
@param offsetx holds offset for the X location in percentage (0-100)
@param offsety holds offset for the Y location in percentage (0-100) */
mpText(wxString name = wxT("Title"), int offsetx = 5, int offsety = 50);
/** Text Layer plot handler.
This implementation will plot text adjusted to the visible area. */
virtual void Plot(wxDC &dc, mpWindow &w);
/** mpText should not be used for scaling decisions. */
virtual bool HasBBox() { return FALSE; }
protected:
int m_offsetx; //!< Holds offset for X in percentage
int m_offsety; //!< Holds offset for Y in percentage
DECLARE_DYNAMIC_CLASS(mpText)
};
//-----------------------------------------------------------------------------
// mpPrintout - provided by Davide Rondini
//-----------------------------------------------------------------------------
/** Printout class used by mpWindow to draw in the objects to be printed.
The object itself can then used by the default wxWidgets printing system
to print mppWindow objects.
*/
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:
mpPrintout() : drawn(false), plotWindow(NULL) {};
bool drawn;
mpWindow *plotWindow;
};
//-----------------------------------------------------------------------------
// mpMovableObject - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
/** This virtual class represents objects that can be moved to an arbitrary 2D
* location+rotation.
* The current transformation is set through SetCoordinateBase.
* To ease the implementation of descendent classes, mpMovableObject will
* be in charge of Bounding Box computation and layer rendering, assuming that
* the object updates its shape in m_shape_xs & m_shape_ys.
*/
class WXDLLIMPEXP_MATHPLOT mpMovableObject : public mpLayer {
public:
/** Default constructor (sets location and rotation to (0,0,0))
*/
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(){};
/** Get the current coordinate transformation.
*/
void GetCoordinateBase(double &x, double &y, double &phi) const {
x = m_reference_x;
y = m_reference_y;
phi = m_reference_phi;
}
/** Set the coordinate transformation (phi in radians, 0 means no rotation).
*/
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; }
/** Get inclusive left border of bounding box.
*/
virtual double GetMinX() { return m_bbox_min_x; }
/** Get inclusive right border of bounding box.
*/
virtual double GetMaxX() { return m_bbox_max_x; }
/** Get inclusive bottom border of bounding box.
*/
virtual double GetMinY() { return m_bbox_min_y; }
/** Get inclusive top border of bounding box.
*/
virtual double GetMaxY() { return m_bbox_max_y; }
virtual void Plot(wxDC &dc, mpWindow &w);
/** Set label axis alignment.
* @param align alignment (choose between mpALIGN_NE, mpALIGN_NW,
* mpALIGN_SW, mpALIGN_SE
*/
void SetAlign(int align) { m_flags = align; };
protected:
int m_flags; //!< Holds label alignment
/** The coordinates of the object (orientation "phi" is in radians).
*/
double m_reference_x, m_reference_y, m_reference_phi;
/** A method for 2D translation and rotation, using the current transformation
* stored in m_reference_x,m_reference_y,m_reference_phi.
*/
void TranslatePoint(double x, double y, double &out_x, double &out_y);
/** This contains the object points, in local coordinates (to be transformed
* by the current transformation).
*/
std::vector<double> m_shape_xs, m_shape_ys;
/** The buffer for the translated & rotated points (to avoid recomputing them
*with each mpWindow refresh).
*
*/
std::vector<double> m_trans_shape_xs, m_trans_shape_ys;
/** The precomputed bounding box:
* @sa ShapeUpdated
*/
double m_bbox_min_x, m_bbox_max_x, m_bbox_min_y, m_bbox_max_y;
/** Must be called by the descendent class after updating the shape
* (m_shape_xs/ys), or when the transformation changes.
* This method updates the buffers m_trans_shape_xs/ys, and the precomputed
* bounding box.
*/
void ShapeUpdated();
};
//-----------------------------------------------------------------------------
// mpCovarianceEllipse - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
/** A 2D ellipse, described by a 2x2 covariance matrix.
* The relation between the multivariate Gaussian confidence interval and
* the "quantiles" in this class is:
* - 1 : 68.27% confidence interval
* - 2 : 95.45%
* - 3 : 99.73%
* - 4 : 99.994%
* For example, see
*http://en.wikipedia.org/wiki/Normal_distribution#Standard_deviation_and_confidence_intervals
*
* The ellipse will be always centered at the origin. Use
*mpMovableObject::SetCoordinateBase to move it.
*/
class WXDLLIMPEXP_MATHPLOT mpCovarianceEllipse : public mpMovableObject {
public:
/** Default constructor.
* Initializes to a unity diagonal covariance matrix, a 95% confidence
* interval (2 sigmas), 32 segments, and a continuous plot
* (m_continuous=true).
*/
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; }
/** Set how many "quantiles" to draw, that is, the confidence interval of the
* ellipse (see above).
*/
void SetQuantiles(double q) {
m_quantiles = q;
RecalculateShape();
}
void SetSegments(int segments) { m_segments = segments; }
int GetSegments() const { return m_segments; }
/** Returns the elements of the current covariance matrix:
*/
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;
}
/** Changes the covariance matrix:
*/
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:
/** The elements of the matrix (only 3 since cov(0,1)=cov(1,0) in any positive
* definite matrix).
*/
double m_cov_00, m_cov_11, m_cov_01;
double m_quantiles;
/** The number of line segments that build up the ellipse.
*/
int m_segments;
/** Called to update the m_shape_xs, m_shape_ys vectors, whenever a parameter
* changes.
*/
void RecalculateShape();
};
//-----------------------------------------------------------------------------
// mpPolygon - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
/** An arbitrary polygon, descendant of mpMovableObject.
* Use "setPoints" to set the list of N points. This class also can draw
* non-closed polygons by
* passing the appropriate parameters to "setPoints". To draw a point-cloud,
* call "SetContinuity(false)".
*/
class WXDLLIMPEXP_MATHPLOT mpPolygon : public mpMovableObject {
public:
/** Default constructor.
*/
mpPolygon(const wxString &layerName = wxT("")) {
m_continuous = true;
m_name = layerName;
}
virtual ~mpPolygon() {}
/** Set the points in the polygon.
* @param points_xs The X coordinates of the points.
* @param points_ys The Y coordinates of the points.
* @param closedShape If set to true, an additional segment will be added
* from the last to the first point.
*/
void setPoints(const std::vector<double> &points_xs,
const std::vector<double> &points_ys, bool closedShape = true);
};
//-----------------------------------------------------------------------------
// mpMovableObject - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
/** This virtual class represents objects that can be moved to an arbitrary 2D
* location+rotation.
* The current transformation is set through SetCoordinateBase.
* To ease the implementation of descendent classes, mpMovableObject will
* be in charge of Bounding Box computation and layer render, assuming that
* the object updates its shape in m_shape_xs & m_shape_ys.
*/
class WXDLLIMPEXP_MATHPLOT mpBitmapLayer : public mpLayer {
public:
/** Default constructor.
*/
mpBitmapLayer() {
m_min_x = m_max_x = m_min_y = m_max_y = 0;
m_validImg = false;
m_type = mpLAYER_BITMAP;
}
virtual ~mpBitmapLayer(){};
/** Returns a copy of the current bitmap assigned to the layer.
*/
void GetBitmapCopy(wxImage &outBmp) const;
/** Change the bitmap associated with the layer (to update the screen, refresh
* the mpWindow).
* @param inBmp The bitmap to associate. A copy is made, thus it can be
* released after calling this.
* @param x The left corner X coordinate (in plot units).
* @param y The top corner Y coordinate (in plot units).
* @param lx The width in plot units.
* @param ly The height in plot units.
*/
void SetBitmap(const wxImage &inBmp, double x, double y, double lx,
double ly);
virtual bool HasBBox() { return true; }
/** Get inclusive left border of bounding box.
*/
virtual double GetMinX() { return m_min_x; }
/** Get inclusive right border of bounding box.
*/
virtual double GetMaxX() { return m_max_x; }
/** Get inclusive bottom border of bounding box.
*/
virtual double GetMinY() { return m_min_y; }
/** Get inclusive top border of bounding box.
*/
virtual double GetMaxY() { return m_max_y; }
virtual void Plot(wxDC &dc, mpWindow &w);
/** Set label axis alignment.
* @param align alignment (choose between mpALIGN_NE, mpALIGN_NW,
* mpALIGN_SW, mpALIGN_SE
*/
void SetAlign(int align) { m_flags = align; };
protected:
int m_flags; //!< Holds label alignment
/** The internal copy of the Bitmap:
*/
wxImage m_bitmap;
wxBitmap m_scaledBitmap;
wxCoord m_scaledBitmap_offset_x, m_scaledBitmap_offset_y;
bool m_validImg;
/** The shape of the bitmap:
*/
double m_min_x, m_max_x, m_min_y, m_max_y;
};
/*@}*/
#define DEFAULT_LINE_COLOUR_0 wxColour("#5B9BD5")
#define DEFAULT_LINE_COLOUR_1 wxColour("#ED7D31")
#define DEFAULT_LINE_COLOUR_2 wxColour("#FFC000")
#define DEFAULT_LINE_COLOUR_3 wxColour("#4472C4")
#define DEFAULT_LINE_COLOUR_4 wxColour("#70AD47")
#define DEFAULT_LINE_COLOUR_5 wxColour("#9E480E")
#define DEFAULT_LINE_COLOUR_6 wxColour("#997300")
#define DEFAULT_LINE_COLOUR_7 wxColour("#A5A5A5")
#define DEFAULT_TEXT_COLOUR wxColour("#686868")
#define DEFAULT_AXIS_LABEL_COLOUR DEFAULT_TEXT_COLOUR
#define DEFAULT_AXIS_BORDER_COLOUR wxColour("#8B8B8B")
#define DEFAULT_AXIS_TICK_COLOUR wxColour("#8B8B8B")
#define DEFAULT_TITLE_COLOUR DEFAULT_TEXT_COLOUR
#endif // _MP_MATHPLOT_H_
Reference in a new issue View git blame Copy permalink