KiCad PCB EDA Suite
Loading...
Searching...
No Matches
mathplot.h
Go to the documentation of this file.
1
2// Name: mathplot.cpp
3// Purpose: Framework for plotting in wxWindows
4// Original Author: David Schalig
5// Maintainer: Davide Rondini
6// Contributors: Jose Luis Blanco, Val Greene, Maciej Suminski, Tomasz Wlostowski
7// Created: 21/07/2003
8// Last edit: 05/08/2016
9// Copyright: (c) David Schalig, Davide Rondini
10// Copyright (c) 2021-2024 KiCad Developers, see AUTHORS.txt for contributors.
11// Licence: wxWindows licence
13
14#ifndef _MP_MATHPLOT_H_
15#define _MP_MATHPLOT_H_
16
55// this definition uses windows dll to export function.
56// WXDLLIMPEXP_MATHPLOT definition definition changed to WXDLLIMPEXP_MATHPLOT
57// mathplot_EXPORTS will be defined by cmake
58#ifdef mathplot_EXPORTS
59#define WXDLLIMPEXP_MATHPLOT WXEXPORT
60#define WXDLLIMPEXP_DATA_MATHPLOT( type ) WXEXPORT type
61#else // not making DLL
62#define WXDLLIMPEXP_MATHPLOT
63#define WXDLLIMPEXP_DATA_MATHPLOT( type ) type
64#endif
65
66
67#include <wx/defs.h>
68#include <wx/menu.h>
69#include <wx/scrolwin.h>
70#include <wx/event.h>
71#include <wx/dynarray.h>
72#include <wx/pen.h>
73#include <wx/dcmemory.h>
74#include <wx/string.h>
75#include <wx/print.h>
76#include <wx/image.h>
77
78#include <vector>
79#include <deque>
80#include <stack>
81#include <array>
82#include <algorithm>
83
84// For memory leak debug
85#ifdef _WINDOWS
86#ifdef _DEBUG
87#include <crtdbg.h>
88#define DEBUG_NEW new (_NORMAL_BLOCK, __FILE__, __LINE__)
89#else
90#define DEBUG_NEW new
91#endif // _DEBUG
92#endif // _WINDOWS
93
94// Separation for axes when set close to border
95#define X_BORDER_SEPARATION 40
96#define Y_BORDER_SEPARATION 60
97
98// -----------------------------------------------------------------------------
99// classes
100// -----------------------------------------------------------------------------
101
111
113enum
114{
115 mpID_FIT = 2000, // !< Fit view to match bounding box of all layers
118 mpID_ZOOM_IN, // !< Zoom into view at clickposition / window center
119 mpID_ZOOM_OUT, // !< Zoom out
120 mpID_CENTER, // !< Center view on click position
121};
122
123// -----------------------------------------------------------------------------
124// mpLayer
125// -----------------------------------------------------------------------------
126
127typedef enum __mp_Layer_Type
128{
129 mpLAYER_UNDEF, // !< Layer type undefined
130 mpLAYER_AXIS, // !< Axis type layer
131 mpLAYER_PLOT, // !< Plot type layer
132 mpLAYER_INFO, // !< Info box type layer
133 mpLAYER_BITMAP // !< Bitmap type layer
135
146class mpScaleBase;
147
148class WXDLLIMPEXP_MATHPLOT mpLayer : public wxObject
149{
150public:
151 mpLayer();
152
153 virtual ~mpLayer() {};
154
162 virtual bool HasBBox() const { return true; }
163
171 virtual bool IsInfo() const { return false; };
172
176 virtual double GetMinX() const { return -1.0; }
177
181 virtual double GetMaxX() const { return 1.0; }
182
186 virtual double GetMinY() const { return -1.0; }
187
191 virtual double GetMaxY() const { return 1.0; }
192
234 virtual void Plot( wxDC& dc, mpWindow& w ) = 0;
235
239 const wxString& GetName() const { return m_name; }
240
241 const wxString& GetDisplayName() const
242 {
243 return m_displayName.IsEmpty() ? m_name : m_displayName;
244 }
245
249 const wxFont& GetFont() const { return m_font; }
250
254 const wxPen& GetPen() const { return m_pen; }
255
259 void SetContinuity( bool continuity ) { m_continuous = continuity; }
260
264 bool GetContinuity() const { return m_continuous; }
265
268 void ShowName( bool show ) { m_showName = show; };
269
273 virtual void SetName( const wxString& name ) { m_name = name; }
274
278 void SetFont( const wxFont& font ) { m_font = font; }
279
283 void SetPen( const wxPen& pen ) { m_pen = pen; }
284
287 mpLayerType GetLayerType() const { return m_type; };
288
291 bool IsVisible() const { return m_visible; };
292
295 void SetVisible( bool show ) { m_visible = show; };
296
299 const wxBrush& GetBrush() const { return m_brush; };
300
303 void SetBrush( const wxBrush& brush ) { m_brush = brush; };
304
305protected:
306
307 wxFont m_font; // !< Layer's font
308 wxPen m_pen; // !< Layer's pen
309 wxBrush m_brush; // !< Layer's brush
310 wxString m_name; // !< Layer's name
312 bool m_continuous; // !< Specify if the layer will be plotted as a continuous line or a set of points.
313 bool m_showName; // !< States whether the name of the layer must be shown (default is true).
314 mpLayerType m_type; // !< Define layer type, which is assigned by constructor
315 bool m_visible; // !< Toggles layer visibility
316
317 DECLARE_DYNAMIC_CLASS( mpLayer )
318};
319
320
321// -----------------------------------------------------------------------------
322// mpInfoLayer
323// -----------------------------------------------------------------------------
324
330{
331public:
333 mpInfoLayer();
334
338 mpInfoLayer( wxRect rect, const wxBrush* brush = wxTRANSPARENT_BRUSH );
339
341 virtual ~mpInfoLayer();
342
345 virtual bool HasBBox() const override { return false; }
346
351 virtual void Plot( wxDC& dc, mpWindow& w ) override;
352
356 virtual bool IsInfo() const override { return true; }
357
361 virtual bool Inside( const wxPoint& point ) const;
362
365 virtual void Move( wxPoint delta );
366
368 virtual void UpdateReference();
369
372 wxPoint GetPosition() const;
373
376 wxSize GetSize() const;
377
378protected:
379 wxRect m_dim; // !< The bounding rectangle of the box. It may be resized dynamically
380 // by the Plot method.
381 wxPoint m_reference; // !< Holds the reference point for movements
382 wxBrush m_brush; // !< The brush to be used for the background
383 int m_winX; // !< Holds the mpWindow size. Used to rescale position when window is
384 int m_winY; // resized.
385
386 DECLARE_DYNAMIC_CLASS( mpInfoLayer )
387};
388
393{
394public:
396 mpInfoLegend();
397
402 mpInfoLegend( wxRect rect, const wxBrush* brush = wxTRANSPARENT_BRUSH );
403
406
411 virtual void Plot( wxDC& dc, mpWindow& w ) override;
412
413protected:
414};
415
416
417// -----------------------------------------------------------------------------
418// mpLayer implementations - functions
419// -----------------------------------------------------------------------------
420
425#define mpALIGNMASK 0x03
427#define mpALIGN_RIGHT 0x00
429#define mpALIGN_CENTER 0x01
431#define mpALIGN_LEFT 0x02
433#define mpALIGN_TOP mpALIGN_RIGHT
435#define mpALIGN_BOTTOM mpALIGN_LEFT
437#define mpALIGN_BORDER_BOTTOM 0x04
439#define mpALIGN_BORDER_TOP 0x05
441#define mpALIGN_FAR_RIGHT 0x06
443#define mpX_NORMAL 0x00
445#define mpX_TIME 0x01
447#define mpX_HOURS 0x02
449#define mpX_DATE 0x03
451#define mpX_DATETIME 0x04
453#define mpALIGN_BORDER_LEFT mpALIGN_BORDER_BOTTOM
455#define mpALIGN_BORDER_RIGHT mpALIGN_BORDER_TOP
457#define mpALIGN_NE 0x00
459#define mpALIGN_NW 0x01
461#define mpALIGN_SW 0x02
463#define mpALIGN_SE 0x03
464
476{
477public:
481 mpFX( const wxString& name = wxEmptyString, int flags = mpALIGN_RIGHT );
482
488 virtual double GetY( double x ) const = 0;
489
494 virtual void Plot( wxDC& dc, mpWindow& w ) override;
495
496protected:
497 int m_flags; // !< Holds label alignment
498
499 DECLARE_DYNAMIC_CLASS( mpFX )
500};
501
508{
509public:
513 mpFY( const wxString& name = wxEmptyString, int flags = mpALIGN_TOP );
514
520 virtual double GetX( double y ) const = 0;
521
526 virtual void Plot( wxDC& dc, mpWindow& w ) override;
527
528protected:
529 int m_flags; // !< Holds label alignment
530
531 DECLARE_DYNAMIC_CLASS( mpFY )
532};
533
542{
543public:
547 mpFXY( const wxString& name = wxEmptyString, int flags = mpALIGN_NE );
548
552 virtual void Rewind() = 0;
553 virtual void SetSweepWindow( int aSweepIdx ) { Rewind(); }
554
560 virtual bool GetNextXY( double& x, double& y ) = 0;
561
562 virtual size_t GetCount() const = 0;
563 virtual int GetSweepCount() const { return 1; }
564
569 virtual void Plot( wxDC& dc, mpWindow& w ) override;
570
571 virtual void SetScale( mpScaleBase* scaleX, mpScaleBase* scaleY );
572
573 void UpdateScales();
574
575 double s2x( double plotCoordX ) const;
576 double s2y( double plotCoordY ) const;
577
578 double x2s( double x ) const;
579 double y2s( double y ) const;
580
581protected:
582 int m_flags; // !< Holds label alignment
583
584 // Data to calculate label positioning
585 wxCoord maxDrawX, minDrawX, maxDrawY, minDrawY;
586 // int drawnPoints;
587 mpScaleBase* m_scaleX, * m_scaleY;
588
593 void UpdateViewBoundary( wxCoord xnew, wxCoord ynew );
594
595 DECLARE_DYNAMIC_CLASS( mpFXY )
596};
597
600// -----------------------------------------------------------------------------
601// mpLayer implementations - furniture (scales, ...)
602// -----------------------------------------------------------------------------
603
614{
615public:
616 mpScaleBase();
617 virtual ~mpScaleBase() {};
618
619 virtual bool IsHorizontal() const = 0;
620
621 bool HasBBox() const override { return false; }
622
627 void SetAlign( int align ) { m_flags = align; };
628
629 void SetNameAlign( int align ) { m_nameFlags = align; }
630
634 void SetTicks( bool enable ) { m_ticks = enable; };
635
639 bool GetTicks() const { return m_ticks; };
640
641 void GetDataRange( double& minV, double& maxV ) const
642 {
643 minV = m_minV;
644 maxV = m_maxV;
645 }
646
647 virtual void ExtendDataRange( double minV, double maxV )
648 {
649 if( !m_rangeSet )
650 {
651 m_minV = minV;
652 m_maxV = maxV;
653 m_rangeSet = true;
654 }
655 else
656 {
657 m_minV = std::min( minV, m_minV );
658 m_maxV = std::max( maxV, m_maxV );
659 }
660
661 if( m_minV == m_maxV )
662 {
663 m_minV = m_minV - 1.0;
664 m_maxV = m_maxV + 1.0;
665 }
666 }
667
668 virtual void ResetDataRange()
669 {
670 m_rangeSet = false;
671 }
672
673 double AbsMaxValue() const
674 {
675 return std::max( std::abs( m_maxV ), std::abs( m_minV ) );
676 }
677
678 double AbsVisibleMaxValue() const
679 {
680 return m_absVisibleMaxV;
681 }
682
683 void SetAxisMinMax( bool lock, double minV, double maxV )
684 {
685 m_axisLocked = lock;
686 m_axisMin = minV;
687 m_axisMax = maxV;
688 }
689
690 bool GetAxisMinMax( double* minV, double* maxV )
691 {
692 if( m_axisLocked )
693 {
694 *minV = m_axisMin;
695 *maxV = m_axisMax;
696 }
697 else if( !m_tickValues.empty() )
698 {
699 *minV = m_tickValues.front();
700 *maxV = m_tickValues.back();
701 }
702
703 return m_axisLocked;
704 }
705
706 virtual double TransformToPlot( double x ) const { return 0.0; };
707 virtual double TransformFromPlot( double xplot ) const { return 0.0; };
708
710 {
711 TICK_LABEL( double pos_ = 0.0, const wxString& label_ = wxT( "" ) ) :
712 pos( pos_ ),
713 label( label_ ),
714 visible( true )
715 {}
716
717 double pos;
718 wxString label;
720 };
721
722protected:
723
724 void updateTickLabels( wxDC& dc, mpWindow& w );
725 void computeLabelExtents( wxDC& dc, mpWindow& w );
726
727 // virtual int getLabelDecimalDigits(int maxDigits) const;
728 virtual void getVisibleDataRange( mpWindow& w, double& minV, double& maxV ) {};
729 virtual void recalculateTicks( wxDC& dc, mpWindow& w ) {};
730
731 virtual void formatLabels() {};
732
733protected:
734 std::vector<double> m_tickValues;
735 std::vector<TICK_LABEL> m_tickLabels;
736
737 double m_offset, m_scale;
739 int m_flags; // !< Flag for axis alignment
741 bool m_ticks; // !< Flag to toggle between ticks or grid
742 double m_minV, m_maxV;
745 double m_axisMin;
746 double m_axisMax;
749};
750
752{
753public:
761 mpScaleXBase( const wxString& name = wxT( "X" ), int flags = mpALIGN_CENTER, bool ticks = true,
762 unsigned int type = mpX_NORMAL );
763 virtual ~mpScaleXBase() {};
764
765 virtual bool IsHorizontal() const override { return true; }
766 virtual void Plot( wxDC& dc, mpWindow& w ) override;
767
768 virtual void getVisibleDataRange( mpWindow& w, double& minV, double& maxV ) override;
769
770 DECLARE_DYNAMIC_CLASS( mpScaleXBase )
771};
772
773
775{
776public:
784 mpScaleX( const wxString& name = wxT( "X" ), int flags = mpALIGN_CENTER, bool ticks = true,
785 unsigned int type = mpX_NORMAL );
786
787 virtual double TransformToPlot( double x ) const override;
788 virtual double TransformFromPlot( double xplot ) const override;
789
790protected:
791 virtual void recalculateTicks( wxDC& dc, mpWindow& w ) override;
792
793 DECLARE_DYNAMIC_CLASS( mpScaleX )
794};
795
796
798{
799public:
807 mpScaleXLog( const wxString& name = wxT( "log(X)" ), int flags = mpALIGN_CENTER,
808 bool ticks = true, unsigned int type = mpX_NORMAL );
809
810 virtual double TransformToPlot( double x ) const override;
811 virtual double TransformFromPlot( double xplot ) const override;
812
813protected:
814 void recalculateTicks( wxDC& dc, mpWindow& w ) override;
815
816 DECLARE_DYNAMIC_CLASS( mpScaleXLog )
817};
818
819
828{
829public:
835 mpScaleY( const wxString& name = wxT( "Y" ), int flags = mpALIGN_CENTER, bool ticks = true );
836
837 virtual bool IsHorizontal() const override { return false; }
838
842 virtual void Plot( wxDC& dc, mpWindow& w ) override;
843
848 virtual bool HasBBox() const override { return false; }
849
850 virtual double TransformToPlot( double x ) const override;
851 virtual double TransformFromPlot( double xplot ) const override;
852
853 void SetMasterScale( mpScaleY* masterScale ) { m_masterScale = masterScale; }
854
855protected:
856 virtual void getVisibleDataRange( mpWindow& w, double& minV, double& maxV ) override;
857 virtual void recalculateTicks( wxDC& dc, mpWindow& w ) override;
858
859 void computeSlaveTicks( mpWindow& w );
860
862 int m_flags; // !< Flag for axis alignment
863 bool m_ticks; // !< Flag to toggle between ticks or grid
864
865 DECLARE_DYNAMIC_CLASS( mpScaleY )
866};
867
868// -----------------------------------------------------------------------------
869// mpWindow
870// -----------------------------------------------------------------------------
871
876#define mpMOUSEMODE_DRAG 0
878#define mpMOUSEMODE_ZOOMBOX 1
879
882// WX_DECLARE_HASH_MAP( int, mpLayer*, wxIntegerHash, wxIntegerEqual, wxLayerList );
883typedef std::deque<mpLayer*> wxLayerList;
884
907class WXDLLIMPEXP_MATHPLOT mpWindow : public wxWindow
908{
909public:
914 {
915 NONE,
919 ZOOM,
922 COUNT // Internal use only
923 };
924
929 {
930 /* If this bundled wxMathPlot implementation is to remain single-header and not dependent
931 * on any part of KiCad, then the SIM_MOUSE_WHEEL_ACTION_SET struct must be duplicated
932 * here. SIM_PLOT_TAB::convertMouseWheelActions is used to convert from
933 * SIM_MOUSE_WHEEL_ACTION_SET to mpWindow::MouseWheelActionSet. */
934
940 };
941
942 mpWindow();
943 mpWindow( wxWindow* parent, wxWindowID id );
944 ~mpWindow();
945
949 wxMenu* GetPopupMenu() { return &m_popmenu; }
950
959 bool AddLayer( mpLayer* layer, bool refreshDisplay = true );
960
971 bool DelLayer( mpLayer* layer, bool alsoDeleteObject = false, bool refreshDisplay = true );
972
979 void DelAllLayers( bool alsoDeleteObject, bool refreshDisplay = true );
980
981
987 mpLayer* GetLayer( int position ) const;
988
993 const mpLayer* GetLayerByName( const wxString& name ) const;
994 mpLayer* GetLayerByName( const wxString& name )
995 {
996 return const_cast<mpLayer*>( static_cast<const mpWindow*>( this )->GetLayerByName( name ) );
997 }
998
1003 double GetScaleX() const { return m_scaleX; };
1004
1009 double GetScaleY() const { return m_scaleY; }
1010
1015 double GetPosX() const { return m_posX; }
1016
1021 double GetPosY() const { return m_posY; }
1022
1029 int GetScrX() const { return m_scrX; }
1030 int GetXScreen() const { return m_scrX; }
1031
1038 int GetScrY() const { return m_scrY; }
1039 int GetYScreen() const { return m_scrY; }
1040
1044 void SetScaleX( double scaleX );
1045
1049 void SetScaleY( double scaleY )
1050 {
1051 if( scaleY != 0 )
1052 m_scaleY = scaleY;
1053
1054 UpdateAll();
1055 }
1056
1060 void SetPosX( double posX ) { m_posX = posX; UpdateAll(); }
1061
1065 void SetPosY( double posY ) { m_posY = posY; UpdateAll(); }
1066
1071 void SetPos( double posX, double posY ) { m_posX = posX; m_posY = posY; UpdateAll(); }
1072
1078 void SetScr( int scrX, int scrY ) { m_scrX = scrX; m_scrY = scrY; }
1079
1082 inline double p2x( wxCoord pixelCoordX ) { return m_posX + pixelCoordX / m_scaleX; }
1083
1086 inline double p2y( wxCoord pixelCoordY ) { return m_posY - pixelCoordY / m_scaleY; }
1087
1090 inline wxCoord x2p( double x ) { return (wxCoord) ( (x - m_posX) * m_scaleX ); }
1091
1094 inline wxCoord y2p( double y ) { return (wxCoord) ( (m_posY - y) * m_scaleY ); }
1095
1096
1099 void EnableDoubleBuffer( bool enabled ) { m_enableDoubleBuffer = enabled; }
1100
1103 void EnableMousePanZoom( bool enabled ) { m_enableMouseNavigation = enabled; }
1104
1106 void SetMouseWheelActions( const MouseWheelActionSet& s ) { m_mouseWheelActions = s; }
1107
1112 void Fit() override;
1113
1120 void Fit( double xMin, double xMax, double yMin, double yMax,
1121 const wxCoord* printSizeX = nullptr, const wxCoord* printSizeY = nullptr,
1122 wxOrientation directions = wxBOTH );
1123
1128 void ZoomIn( const wxPoint& centerPoint = wxDefaultPosition );
1129 void ZoomIn( const wxPoint& centerPoint, double zoomFactor, wxOrientation directions = wxBOTH );
1130
1135 void ZoomOut( const wxPoint& centerPoint = wxDefaultPosition );
1136 void ZoomOut( const wxPoint& centerPoint, double zoomFactor,
1137 wxOrientation directions = wxBOTH );
1138
1141 void ZoomRect( wxPoint p0, wxPoint p1 );
1142
1144 void UpdateAll();
1145
1146 // Added methods by Davide Rondini
1147
1150 unsigned int CountAllLayers() const { return m_layers.size(); };
1151
1156 double GetDesiredXmin() const { return m_desiredXmin; }
1157
1162 double GetDesiredXmax() const { return m_desiredXmax; }
1163
1168 double GetDesiredYmin() const { return m_desiredYmin; }
1169
1174 double GetDesiredYmax() const { return m_desiredYmax; }
1175
1179 void GetBoundingBox( double* bbox ) const;
1180
1186 bool SaveScreenshot( wxImage& aImage,
1187 wxSize aImageSize = wxDefaultSize, bool aFit = false );
1188
1194
1201 void SetMargins( int top, int right, int bottom, int left );
1202
1204 void SetMarginTop( int top ) { m_marginTop = top; };
1206 void SetMarginRight( int right ) { m_marginRight = right; };
1208 void SetMarginBottom( int bottom ) { m_marginBottom = bottom; };
1210 void SetMarginLeft( int left ) { m_marginLeft = left; };
1211
1213 int GetMarginTop() const { return m_marginTop; };
1215 int GetMarginRight() const { return m_marginRight; };
1217 int GetMarginBottom() const { return m_marginBottom; };
1219 int GetMarginLeft() const { return m_marginLeft; };
1220
1224 mpInfoLayer* IsInsideInfoLayer( wxPoint& point );
1225
1229 void SetLayerVisible( const wxString& name, bool viewable );
1230
1234 bool IsLayerVisible( const wxString& name ) const;
1235
1239 void SetLayerVisible( const unsigned int position, bool viewable );
1240
1244 bool IsLayerVisible( unsigned int position ) const;
1245
1250 void SetColourTheme( const wxColour& bgColour, const wxColour& drawColour,
1251 const wxColour& axesColour );
1252
1255 const wxColour& GetAxesColour() { return m_axColour; };
1256
1258 void LimitView( bool aEnable )
1259 {
1260 m_enableLimitedView = aEnable;
1261 }
1262
1263 void LockY( bool aLock ) { m_yLocked = aLock; }
1264 bool GetYLocked() const { return m_yLocked; }
1265
1266 void ZoomUndo();
1267 void ZoomRedo();
1268 int UndoZoomStackSize() const { return m_undoZoomStack.size(); }
1269 int RedoZoomStackSize() const { return m_redoZoomStack.size(); }
1270
1272 void AdjustLimitedView( wxOrientation directions = wxBOTH );
1273
1274 void OnFit( wxCommandEvent& event );
1275 void OnCenter( wxCommandEvent& event );
1276
1277protected:
1278 static MouseWheelActionSet defaultMouseWheelActions();
1279
1280 void pushZoomUndo( const std::array<double, 4>& aZoom );
1281
1282 void OnPaint( wxPaintEvent& event ); // !< Paint handler, will plot all attached layers
1283 void OnSize( wxSizeEvent& event ); // !< Size handler, will update scroll bar sizes
1284
1285 void OnShowPopupMenu( wxMouseEvent& event ); // !< Mouse handler, will show context menu
1286 void OnMouseMiddleDown( wxMouseEvent& event ); // !< Mouse handler, for detecting when the user
1287
1288 // !< drags with the middle button or just "clicks" for the menu
1289 void onZoomIn( wxCommandEvent& event ); // !< Context menu handler
1290 void onZoomOut( wxCommandEvent& event ); // !< Context menu handler
1291 void onZoomUndo( wxCommandEvent& event ); // !< Context menu handler
1292 void onZoomRedo( wxCommandEvent& event ); // !< Context menu handler
1293 void onMouseWheel( wxMouseEvent& event ); // !< Mouse handler for the wheel
1294 void onMagnify( wxMouseEvent& event ); // !< Pinch zoom handler
1295 void onMouseMove( wxMouseEvent& event ); // !< Mouse handler for mouse motion (for pan)
1296 void onMouseLeftDown( wxMouseEvent& event ); // !< Mouse left click (for rect zoom)
1297 void onMouseLeftRelease( wxMouseEvent& event ); // !< Mouse left click (for rect zoom)
1298
1299 void DoZoom( const wxPoint& centerPoint, double zoomFactor, wxOrientation directions );
1300 void RecomputeDesiredX( double& min, double& max );
1301 void RecomputeDesiredY( double& min, double& max );
1302 wxOrientation ViewNeedsRefitting( wxOrientation directions ) const;
1303
1304 void PerformMouseWheelAction( wxMouseEvent& event, MouseWheelAction action );
1305
1309 virtual bool UpdateBBox();
1310
1314 virtual bool SetXView( double pos, double desiredMax, double desiredMin );
1315
1319 virtual bool SetYView( double pos, double desiredMax, double desiredMin );
1320
1321 // wxList m_layers; //!< List of attached plot layers
1322 wxLayerList m_layers; // !< List of attached plot layers
1323 wxMenu m_popmenu; // !< Canvas' context menu
1324 wxColour m_bgColour; // !< Background Colour
1325 wxColour m_fgColour; // !< Foreground Colour
1326 wxColour m_axColour; // !< Axes Colour
1327
1328 double m_minX; // !< Global layer bounding box, left border incl.
1329 double m_maxX; // !< Global layer bounding box, right border incl.
1330 double m_minY; // !< Global layer bounding box, bottom border incl.
1331 double m_maxY; // !< Global layer bounding box, top border incl.
1332 double m_scaleX; // !< Current view's X scale
1333 double m_scaleY; // !< Current view's Y scale
1334 double m_posX; // !< Current view's X position
1335 double m_posY; // !< Current view's Y position
1336 int m_scrX; // !< Current view's X dimension
1337 int m_scrY; // !< Current view's Y dimension
1338 int m_clickedX; // !< Last mouse click X position, for centering and zooming the view
1339 int m_clickedY; // !< Last mouse click Y position, for centering and zooming the view
1340
1342
1349 double m_desiredXmin, m_desiredXmax, m_desiredYmin, m_desiredYmax;
1350
1351 // These are gaps between the curve extrema and the edges of the plot area, expressed as
1352 // a factor of global layer bounding box width/height.
1355
1356 int m_marginTop, m_marginRight, m_marginBottom, m_marginLeft;
1357
1358 int m_last_lx, m_last_ly; // !< For double buffering
1359 wxMemoryDC m_buff_dc; // !< For double buffering
1360 wxBitmap* m_buff_bmp; // !< For double buffering
1361 bool m_enableDoubleBuffer; // !< For double buffering
1362 bool m_enableMouseNavigation; // !< For pan/zoom with the mouse.
1365 wxPoint m_mouseMClick; // !< For the middle button "drag" feature
1366 wxPoint m_mouseLClick; // !< Starting coords for rectangular zoom selection
1367 mpInfoLayer* m_movingInfoLayer; // !< For moving info layers over the window area
1370 std::stack<std::array<double, 4>> m_undoZoomStack;
1371 std::stack<std::array<double, 4>> m_redoZoomStack;
1372
1373 DECLARE_DYNAMIC_CLASS( mpWindow )
1374 DECLARE_EVENT_TABLE()
1375
1376private:
1378
1379 template <typename... Ts>
1380 mpWindow( DelegatingContructorTag, Ts&&... windowArgs );
1381
1382 void initializeGraphicsContext();
1383};
1384
1385// -----------------------------------------------------------------------------
1386// mpFXYVector - provided by Jose Luis Blanco
1387// -----------------------------------------------------------------------------
1388
1409{
1410public:
1414 mpFXYVector( const wxString& name = wxEmptyString, int flags = mpALIGN_NE );
1415
1416 virtual ~mpFXYVector() {}
1417
1422 virtual void SetData( const std::vector<double>& xs, const std::vector<double>& ys );
1423
1424 void SetSweepCount( int aSweepCount ) { m_sweepCount = aSweepCount; }
1425 void SetSweepSize( size_t aSweepSize ) { m_sweepSize = aSweepSize; }
1426
1430 void Clear();
1431
1432protected:
1435 std::vector<double> m_xs, m_ys;
1436
1437 size_t m_index; // internal counter for the "GetNextXY" interface
1438 size_t m_sweepWindow; // last m_index of the current sweep
1439
1442 double m_minX, m_maxX, m_minY, m_maxY;
1443 int m_sweepCount = 1; // sweeps to split data into
1444 size_t m_sweepSize = std::numeric_limits<size_t>::max(); // data-points in each sweep
1445
1449 void Rewind() override;
1450 void SetSweepWindow( int aSweepIdx ) override;
1451
1457 bool GetNextXY( double& x, double& y ) override;
1458
1459 size_t GetCount() const override { return m_xs.size(); }
1460 int GetSweepCount() const override { return m_sweepCount; }
1461
1462public:
1465 double GetMinX() const override { return m_minX; }
1466
1469 double GetMinY() const override { return m_minY; }
1470
1473 double GetMaxX() const override { return m_maxX; }
1474
1477 double GetMaxY() const override { return m_maxY; }
1478
1479protected:
1480
1481 DECLARE_DYNAMIC_CLASS( mpFXYVector )
1482};
1483
1484
1485#endif // _MP_MATHPLOT_H_
const char * name
Definition: DXF_plotter.cpp:57
A class providing graphs functionality for a 2D plot (either continuous or a set of points),...
Definition: mathplot.h:1409
double GetMaxY() const override
Returns the actual maximum Y data (loaded in SetData).
Definition: mathplot.h:1477
void SetSweepSize(size_t aSweepSize)
Definition: mathplot.h:1425
double GetMinY() const override
Returns the actual minimum Y data (loaded in SetData).
Definition: mathplot.h:1469
double GetMinX() const override
Returns the actual minimum X data (loaded in SetData).
Definition: mathplot.h:1465
std::vector< double > m_xs
The internal copy of the set of data to draw.
Definition: mathplot.h:1435
size_t m_sweepWindow
Definition: mathplot.h:1438
double m_maxX
Definition: mathplot.h:1442
double GetMaxX() const override
Returns the actual maximum X data (loaded in SetData).
Definition: mathplot.h:1473
void SetSweepCount(int aSweepCount)
Definition: mathplot.h:1424
virtual ~mpFXYVector()
Definition: mathplot.h:1416
size_t GetCount() const override
Definition: mathplot.h:1459
size_t m_index
Definition: mathplot.h:1437
int GetSweepCount() const override
Definition: mathplot.h:1460
Abstract base class providing plot and labeling functionality for a locus plot F:N->X,...
Definition: mathplot.h:542
mpScaleBase * m_scaleX
Definition: mathplot.h:587
wxCoord maxDrawX
Definition: mathplot.h:585
virtual void Rewind()=0
Rewind value enumeration with mpFXY::GetNextXY.
virtual void SetSweepWindow(int aSweepIdx)
Definition: mathplot.h:553
virtual size_t GetCount() const =0
int m_flags
Definition: mathplot.h:582
virtual int GetSweepCount() const
Definition: mathplot.h:563
virtual bool GetNextXY(double &x, double &y)=0
Get locus value for next N.
Abstract base class providing plot and labeling functionality for functions F:X->Y.
Definition: mathplot.h:476
virtual double GetY(double x) const =0
Get function value for argument.
int m_flags
Definition: mathplot.h:497
Abstract base class providing plot and labeling functionality for functions F:Y->X.
Definition: mathplot.h:508
int m_flags
Definition: mathplot.h:529
virtual double GetX(double y) const =0
Get function value for argument.
Base class to create small rectangular info boxes mpInfoLayer is the base class to create a small rec...
Definition: mathplot.h:330
virtual bool HasBBox() const override
mpInfoLayer has not bounding box.
Definition: mathplot.h:345
wxPoint m_reference
Definition: mathplot.h:381
wxRect m_dim
Definition: mathplot.h:379
int m_winY
Definition: mathplot.h:384
virtual bool IsInfo() const override
Specifies that this is an Info box layer.
Definition: mathplot.h:356
wxBrush m_brush
Definition: mathplot.h:382
int m_winX
Definition: mathplot.h:383
Implements the legend to be added to the plot This layer allows you to add a legend to describe the p...
Definition: mathplot.h:393
const wxString & GetDisplayName() const
Definition: mathplot.h:241
virtual void Plot(wxDC &dc, mpWindow &w)=0
Plot given view of layer to the given device context.
mpLayerType GetLayerType() const
Get layer type: a Layer can be of different types: plot lines, axis, info boxes, etc,...
Definition: mathplot.h:287
wxFont m_font
Definition: mathplot.h:307
void SetFont(const wxFont &font)
Set layer font.
Definition: mathplot.h:278
bool IsVisible() const
Checks whether the layer is visible or not.
Definition: mathplot.h:291
const wxString & GetName() const
Get layer name.
Definition: mathplot.h:239
virtual ~mpLayer()
Definition: mathplot.h:153
virtual double GetMinY() const
Get inclusive bottom border of bounding box.
Definition: mathplot.h:186
bool GetContinuity() const
Gets the 'continuity' property of the layer.
Definition: mathplot.h:264
bool m_continuous
Definition: mathplot.h:312
bool m_showName
Definition: mathplot.h:313
bool m_visible
Definition: mathplot.h:315
virtual bool IsInfo() const
Check whether the layer is an info box.
Definition: mathplot.h:171
void SetContinuity(bool continuity)
Set the 'continuity' property of the layer (true:draws a continuous line, false:draws separate points...
Definition: mathplot.h:259
void ShowName(bool show)
Shows or hides the text label with the name of the layer (default is visible).
Definition: mathplot.h:268
virtual void SetName(const wxString &name)
Set layer name.
Definition: mathplot.h:273
const wxFont & GetFont() const
Get font set for this layer.
Definition: mathplot.h:249
const wxPen & GetPen() const
Get pen set for this layer.
Definition: mathplot.h:254
mpLayerType m_type
Definition: mathplot.h:314
void SetVisible(bool show)
Sets layer visibility.
Definition: mathplot.h:295
wxString m_name
Definition: mathplot.h:310
wxBrush m_brush
Definition: mathplot.h:309
wxString m_displayName
Definition: mathplot.h:311
void SetPen(const wxPen &pen)
Set layer pen.
Definition: mathplot.h:283
wxPen m_pen
Definition: mathplot.h:308
void SetBrush(const wxBrush &brush)
Set layer brush.
Definition: mathplot.h:303
virtual double GetMaxX() const
Get inclusive right border of bounding box.
Definition: mathplot.h:181
const wxBrush & GetBrush() const
Get brush set for this layer.
Definition: mathplot.h:299
virtual double GetMinX() const
Get inclusive left border of bounding box.
Definition: mathplot.h:176
virtual double GetMaxY() const
Get inclusive top border of bounding box.
Definition: mathplot.h:191
virtual bool HasBBox() const
Check whether this layer has a bounding box.
Definition: mathplot.h:162
Plot layer implementing a x-scale ruler.
Definition: mathplot.h:614
void SetAxisMinMax(bool lock, double minV, double maxV)
Definition: mathplot.h:683
bool m_axisLocked
Definition: mathplot.h:744
void SetNameAlign(int align)
Definition: mathplot.h:629
virtual void recalculateTicks(wxDC &dc, mpWindow &w)
Definition: mathplot.h:729
double m_offset
Definition: mathplot.h:737
double AbsMaxValue() const
Definition: mathplot.h:673
void GetDataRange(double &minV, double &maxV) const
Definition: mathplot.h:641
std::vector< double > m_tickValues
Definition: mathplot.h:734
bool m_rangeSet
Definition: mathplot.h:743
double AbsVisibleMaxValue() const
Definition: mathplot.h:678
bool HasBBox() const override
Check whether this layer has a bounding box.
Definition: mathplot.h:621
void SetAlign(int align)
Set X axis alignment.
Definition: mathplot.h:627
void SetTicks(bool enable)
Set X axis ticks or grid.
Definition: mathplot.h:634
virtual double TransformToPlot(double x) const
Definition: mathplot.h:706
virtual void ResetDataRange()
Definition: mathplot.h:668
virtual void formatLabels()
Definition: mathplot.h:731
int m_maxLabelHeight
Definition: mathplot.h:747
virtual bool IsHorizontal() const =0
double m_axisMin
Definition: mathplot.h:745
double m_maxV
Definition: mathplot.h:742
int m_maxLabelWidth
Definition: mathplot.h:748
bool GetTicks() const
Get X axis ticks or grid.
Definition: mathplot.h:639
virtual void ExtendDataRange(double minV, double maxV)
Definition: mathplot.h:647
std::vector< TICK_LABEL > m_tickLabels
Definition: mathplot.h:735
double m_absVisibleMaxV
Definition: mathplot.h:738
bool m_ticks
Definition: mathplot.h:741
bool GetAxisMinMax(double *minV, double *maxV)
Definition: mathplot.h:690
virtual void getVisibleDataRange(mpWindow &w, double &minV, double &maxV)
Definition: mathplot.h:728
int m_flags
Definition: mathplot.h:739
int m_nameFlags
Definition: mathplot.h:740
virtual ~mpScaleBase()
Definition: mathplot.h:617
virtual double TransformFromPlot(double xplot) const
Definition: mathplot.h:707
double m_axisMax
Definition: mathplot.h:746
virtual ~mpScaleXBase()
Definition: mathplot.h:763
virtual bool IsHorizontal() const override
Definition: mathplot.h:765
Plot layer implementing a y-scale ruler.
Definition: mathplot.h:828
int m_flags
Definition: mathplot.h:862
mpScaleY * m_masterScale
Definition: mathplot.h:861
virtual bool IsHorizontal() const override
Definition: mathplot.h:837
void SetMasterScale(mpScaleY *masterScale)
Definition: mathplot.h:853
bool m_ticks
Definition: mathplot.h:863
virtual bool HasBBox() const override
Check whether this layer has a bounding box.
Definition: mathplot.h:848
Canvas for plotting mpLayer implementations.
Definition: mathplot.h:908
mpInfoLayer * m_movingInfoLayer
Definition: mathplot.h:1367
bool m_zooming
Definition: mathplot.h:1368
int RedoZoomStackSize() const
Definition: mathplot.h:1269
double m_maxY
Definition: mathplot.h:1331
double m_posY
Definition: mathplot.h:1335
int GetMarginLeft() const
Definition: mathplot.h:1219
bool m_enableMouseNavigation
Definition: mathplot.h:1362
int GetYScreen() const
Definition: mathplot.h:1039
void EnableMousePanZoom(bool enabled)
Enable/disable the feature of pan/zoom with the mouse (default=enabled)
Definition: mathplot.h:1103
void SetMarginLeft(int left)
Set the left margin.
Definition: mathplot.h:1210
const wxColour & GetAxesColour()
Get axes draw colour.
Definition: mathplot.h:1255
double m_desiredXmax
Definition: mathplot.h:1349
int m_last_lx
Definition: mathplot.h:1358
MouseWheelActionSet m_mouseWheelActions
Definition: mathplot.h:1364
double m_minY
Definition: mathplot.h:1330
int GetScrX() const
Get current view's X dimension in device context units.
Definition: mathplot.h:1029
int GetScrY() const
Get current view's Y dimension in device context units.
Definition: mathplot.h:1038
void SetMouseWheelActions(const MouseWheelActionSet &s)
Set the pan/zoom actions corresponding to mousewheel/trackpad events.
Definition: mathplot.h:1106
double p2x(wxCoord pixelCoordX)
Converts mpWindow (screen) pixel coordinates into graph (floating point) coordinates,...
Definition: mathplot.h:1082
double p2y(wxCoord pixelCoordY)
Converts mpWindow (screen) pixel coordinates into graph (floating point) coordinates,...
Definition: mathplot.h:1086
wxMemoryDC m_buff_dc
Definition: mathplot.h:1359
double m_maxX
Definition: mathplot.h:1329
void SetMarginRight(int right)
Set the right margin.
Definition: mathplot.h:1206
int m_marginBottom
Definition: mathplot.h:1356
void LimitView(bool aEnable)
Enable limiting of zooming & panning to the area used by the plots.
Definition: mathplot.h:1258
int m_clickedY
Definition: mathplot.h:1339
wxCoord x2p(double x)
Converts graph (floating point) coordinates into mpWindow (screen) pixel coordinates,...
Definition: mathplot.h:1090
wxColour m_bgColour
Definition: mathplot.h:1324
MouseWheelAction
Enumerates the possible mouse wheel actions that can be performed on the plot.
Definition: mathplot.h:914
double m_leftRightPlotGapFactor
Definition: mathplot.h:1354
double m_posX
Definition: mathplot.h:1334
wxPoint m_mouseLClick
Definition: mathplot.h:1366
void SetMarginTop(int top)
Set the top margin.
Definition: mathplot.h:1204
std::stack< std::array< double, 4 > > m_redoZoomStack
Definition: mathplot.h:1371
void SetPosX(double posX)
Set current view's X position and refresh display.
Definition: mathplot.h:1060
double GetDesiredYmax() const
Returns the top layer-border coordinate that the user wants the mpWindow to show (it may be not exact...
Definition: mathplot.h:1174
int GetXScreen() const
Definition: mathplot.h:1030
int GetMarginTop() const
Definition: mathplot.h:1213
double m_scaleY
Definition: mathplot.h:1333
void SetMarginBottom(int bottom)
Set the bottom margin.
Definition: mathplot.h:1208
void SetPosY(double posY)
Set current view's Y position and refresh display.
Definition: mathplot.h:1065
void SetScaleY(double scaleY)
Set current view's Y scale and refresh display.
Definition: mathplot.h:1049
wxColour m_fgColour
Definition: mathplot.h:1325
bool GetYLocked() const
Definition: mathplot.h:1264
double GetDesiredYmin() const
Returns the bottom-border layer coordinate that the user wants the mpWindow to show (it may be not ex...
Definition: mathplot.h:1168
double m_minX
Definition: mathplot.h:1328
wxRect m_zoomRect
Definition: mathplot.h:1369
wxLayerList m_layers
Definition: mathplot.h:1322
wxCoord y2p(double y)
Converts graph (floating point) coordinates into mpWindow (screen) pixel coordinates,...
Definition: mathplot.h:1094
double GetDesiredXmax() const
Returns the right-border layer coordinate that the user wants the mpWindow to show (it may be not exa...
Definition: mathplot.h:1162
wxMenu m_popmenu
Definition: mathplot.h:1323
bool m_enableLimitedView
Definition: mathplot.h:1363
int m_clickedX
Definition: mathplot.h:1338
wxBitmap * m_buff_bmp
Definition: mathplot.h:1360
double m_topBottomPlotGapFactor
Definition: mathplot.h:1353
wxMenu * GetPopupMenu()
Get reference to context menu of the plot canvas.
Definition: mathplot.h:949
double GetDesiredXmin() const
Returns the left-border layer coordinate that the user wants the mpWindow to show (it may be not exac...
Definition: mathplot.h:1156
wxPoint m_mouseMClick
Definition: mathplot.h:1365
std::stack< std::array< double, 4 > > m_undoZoomStack
Definition: mathplot.h:1370
int GetMarginRight() const
Definition: mathplot.h:1215
void SetScr(int scrX, int scrY)
Set current view's dimensions in device context units.
Definition: mathplot.h:1078
int GetMarginBottom() const
Definition: mathplot.h:1217
void EnableDoubleBuffer(bool enabled)
Enable/disable the double-buffering of the window, eliminating the flicker (default=disabled).
Definition: mathplot.h:1099
wxColour m_axColour
Definition: mathplot.h:1326
static double zoomIncrementalFactor
This value sets the zoom steps whenever the user clicks "Zoom in/out" or performs zoom with the mouse...
Definition: mathplot.h:1193
mpLayer * GetLayerByName(const wxString &name)
Definition: mathplot.h:994
bool m_yLocked
Definition: mathplot.h:1341
int UndoZoomStackSize() const
Definition: mathplot.h:1268
double m_scaleX
Definition: mathplot.h:1332
bool m_enableDoubleBuffer
Definition: mathplot.h:1361
void LockY(bool aLock)
Definition: mathplot.h:1263
unsigned int CountAllLayers() const
Counts the number of plot layers, whether or not they have a bounding box.
Definition: mathplot.h:1150
void SetPos(double posX, double posY)
Set current view's X and Y position and refresh display.
Definition: mathplot.h:1071
double GetScaleY() const
Get current view's Y scale.
Definition: mathplot.h:1009
int m_scrY
Definition: mathplot.h:1337
double GetScaleX() const
Get current view's X scale.
Definition: mathplot.h:1003
double GetPosY() const
Get current view's Y position.
Definition: mathplot.h:1021
double GetPosX() const
Get current view's X position.
Definition: mathplot.h:1015
int m_scrX
Definition: mathplot.h:1336
@ NONE
Definition: kibis.h:54
class WXDLLIMPEXP_MATHPLOT mpPrintout
Definition: mathplot.h:110
__mp_Layer_Type
Definition: mathplot.h:128
@ mpLAYER_INFO
Definition: mathplot.h:132
@ mpLAYER_BITMAP
Definition: mathplot.h:133
@ mpLAYER_UNDEF
Definition: mathplot.h:129
@ mpLAYER_AXIS
Definition: mathplot.h:130
@ mpLAYER_PLOT
Definition: mathplot.h:131
@ mpID_ZOOM_REDO
Definition: mathplot.h:117
@ mpID_FIT
Definition: mathplot.h:115
@ mpID_ZOOM_IN
Definition: mathplot.h:118
@ mpID_CENTER
Definition: mathplot.h:120
@ mpID_ZOOM_UNDO
Definition: mathplot.h:116
@ mpID_ZOOM_OUT
Definition: mathplot.h:119
#define mpALIGN_RIGHT
Aligns label to the right.
Definition: mathplot.h:427
enum __mp_Layer_Type mpLayerType
std::deque< mpLayer * > wxLayerList
Define the type for the list of layers inside mpWindow.
Definition: mathplot.h:883
#define mpALIGN_CENTER
Aligns label to the center.
Definition: mathplot.h:429
#define mpALIGN_TOP
Aligns label to the top.
Definition: mathplot.h:433
#define WXDLLIMPEXP_MATHPLOT
wxMathPlot is a framework for mathematical graph plotting in wxWindows.
Definition: mathplot.h:62
#define mpX_NORMAL
Set label for X axis in normal mode.
Definition: mathplot.h:443
#define mpALIGN_NE
Aligns label to north-east.
Definition: mathplot.h:457
EDA_ANGLE abs(const EDA_ANGLE &aAngle)
Definition: eda_angle.h:390
TICK_LABEL(double pos_=0.0, const wxString &label_=wxT(""))
Definition: mathplot.h:711
Contains the set of modified mouse wheel actions that can be performed on the plot.
Definition: mathplot.h:929
MouseWheelAction horizontal
Definition: mathplot.h:939
MouseWheelAction verticalWithShift
Definition: mathplot.h:937
MouseWheelAction verticalWithCtrl
Definition: mathplot.h:936
MouseWheelAction verticalWithAlt
Definition: mathplot.h:938
MouseWheelAction verticalUnmodified
Definition: mathplot.h:935
constexpr int delta