rectangularplotwidget.h

Go to the documentation of this file.

 
 
#ifndef RECTANGULARPLOTWIDGET_H
#define RECTANGULARPLOTWIDGET_H
 
#include "./QCustomPlot/qcustomplot.h"
#include "UI/CustomWidgets/CustomDoubleSpinBox.h"
#include <QCheckBox>
#include <QComboBox>
#include <QGridLayout>
#include <QLabel>
#include <QMap>
#include <QPen>
#include <QVBoxLayout>
#include <QWidget>
#include <complex>
#include <limits>
 
class RectangularPlotWidget : public QWidget {
  Q_OBJECT
 
public:
  struct Trace {
    QList<double> trace;          
    QList<double> frequencies;    
    QString units;                
    QPen pen;                     
    double Z0;                    
    int y_axis;                   
    QString y_axis_title;         
  };
 
 
  struct Marker {
    QString id;        
    double frequency;  
    QPen pen;          
  };
 
  struct Limit {
    double f1;   
    double f2;   
    double y1;   
    double y2;   
    int y_axis;  
    QPen pen;    
  };
 
  struct AxisSettings {
    double xAxisMin;      
    double xAxisMax;      
    double xAxisDiv;      
    QString xAxisUnits;   
    double yAxisMin;      
    double yAxisMax;      
    double yAxisDiv;      
    double y2AxisMin;     
    double y2AxisMax;     
    double y2AxisDiv;     
    bool showValues;      
    bool lockAxis;        
    bool lockPan;         
  };
 
  explicit RectangularPlotWidget(QWidget* parent = nullptr);
 
  ~RectangularPlotWidget();
 
  void addTrace(const QString& name, const Trace& trace);
 
  void removeTrace(const QString& name) {
    traces.remove(name);
    updatePlot();
  }
 
  void clearTraces() {
    traces.clear();
    updatePlot();
  }
 
  double calculateNiceStep(double range);
 
  QPen getTracePen(const QString& traceName) const;
 
  void setTracePen(const QString& traceName, const QPen& pen);
 
  QMap<QString, QPen> getTracesInfo() const;
 
  double getYmax() { return yAxisMax->value(); }
 
  double getYmin() { return yAxisMin->value(); }
 
  double getYdiv() { return yAxisDiv->value(); }
 
  void setYdiv(double val) { yAxisDiv->setValue(val); }
 
  void setYmax(double val) { yAxisMax->setValue(val); }
 
  void setYmin(double val) { yAxisMin->setValue(val); }
 
  double getY2max() { return y2AxisMax->value(); }
 
  double getY2min() { return y2AxisMin->value(); }
 
  double getY2div() { return y2AxisDiv->value(); }
 
  double getXmax() { return xAxisMax->value(); }
 
  double getXmin(){ return xAxisMin->value(); }
 
  double getXdiv() { return xAxisDiv->value(); }
 
  double getXscale();
 
  QString getXunits() { return xAxisUnits->currentText(); }
 
  int getFreqIndex()  { return xAxisUnits->currentIndex(); }
 
  void updatePlot();
 
  void set_y_autoscale(bool value) { y_autoscale = value; }
 
  bool areAxisSettingsLocked() const {
    return axisSettingsLocked;
  }
 
  void setRightYAxisEnabled(bool enabled);
 
  bool isRightYAxisEnabled() const {
    return plotWidget->yAxis2->visible();
  }
 
  void change_Y_axis_title(QString title) {
    plotWidget->yAxis->setLabel(title);
    plotWidget->replot();
  }
 
  void change_Y_axis_units(QString units){
    yAxisUnits->setText(units);
  }
 
  void change_Y2_axis_title(QString title){
    plotWidget->yAxis2->setLabel(title);
    plotWidget->replot();
  }
 
  void change_Y2_axis_units(QString units) {
    y2AxisUnits->setText(units);
  }
 
  void change_X_axis_title(QString title){
    plotWidget->xAxis->setLabel(title);
    plotWidget->replot();
  }
 
 
  QLabel* xAxisLabel; 
 
  bool addMarker(const QString& markerId, double frequency,
                 const QPen& pen = QPen(Qt::red, 2));
 
  bool removeMarker(const QString& markerId);
 
  bool updateMarkerFrequency(const QString& markerId, double newFrequency);
 
  void clearMarkers() {
    markers.clear();
    updatePlot();
  }
 
  QMap<QString, double> getMarkers() const;
 
  bool addLimit(const QString& LimitId, const Limit& limit);
 
  void removeLimit(const QString& LimitID);
 
  void clearLimits() {
    limits.clear();
    updatePlot();
  }
 
  QMap<QString, Limit> getLimits() const {
    return limits;
  }
 
  bool updateLimit(const QString& limitId, const Limit& limit);
 
  QCustomPlot* customPlot() const { return plotWidget; }
 
  AxisSettings getSettings() const;
 
  void setSettings(const AxisSettings& settings);
 
private slots:
  void updateXAxis();
 
  void updateYAxis();
 
  void updateY2Axis();
 
  void changeFreqUnits();
 
  void toggleShowValues(bool show);
 
  void toggleLockAxisSettings(bool locked);
 
  void toggleLockPan(bool locked);
 
private slots:
  void onXAxisRangeChanged(const QCPRange& range);
 
  void onYAxisRangeChanged(const QCPRange& range);
 
  void onY2AxisRangeChanged(const QCPRange& range);
 
private:
  QCustomPlot* plotWidget;           
 
  CustomDoubleSpinBox* xAxisMin;          
  CustomDoubleSpinBox* xAxisMax;          
  CustomDoubleSpinBox* xAxisDiv;          
  QComboBox* xAxisUnits;             
 
  CustomDoubleSpinBox* yAxisMin;          
  CustomDoubleSpinBox* yAxisMax;          
  CustomDoubleSpinBox* yAxisDiv;          
  QLabel* yAxisUnits;                
 
  CustomDoubleSpinBox* y2AxisMin;         
  CustomDoubleSpinBox* y2AxisMax;         
  CustomDoubleSpinBox* y2AxisDiv;         
  QLabel* y2AxisUnits;               
  QLabel* y2AxisLabel;               
 
  QCheckBox* showValuesCheckbox;     
  bool showTraceValues;              
 
  QCheckBox* lockAxisCheckbox;       
  bool axisSettingsLocked;           
 
  QCheckBox* lockPanCheckbox;       
 
  QStringList frequencyUnits;        
  double fMin;                       
  double fMax;                       
 
  bool y_autoscale;                  
 
  QMap<QString, Trace> traces;       
  QMap<QString, Marker> markers;     
  QMap<QString, Limit> limits;       
 
  QMap<QString, QCPGraph*> traceGraphs;              
  QMap<QString, QCPItemStraightLine*> markerLines;   
  QMap<QString, QCPItemText*> markerLabels;          
  QMap<QString, QCPItemTracer*> intersectionPoints;  
  QMap<QString, QCPItemText*> intersectionLabels;    
  QMap<QString, QCPGraph*> limitGraphs;              
 
  QGridLayout* setupAxisSettings();
 
  void clearGraphicsItems();
 
  void setupPlot();
 
  void addMarkerIntersections(const QString& markerId, const Marker& marker);
 
  int getYAxisTraceCount() const;
 
  int getY2AxisTraceCount() const;
};
 
#endif // RECTANGULARPLOTWIDGET_H