##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SCIQLOP-Initialisation
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Initialisation of the graph range at creation in a new graphe, or inside...
perrinel -
r518:5673fc6ded12
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,38 +1,40
1 #ifndef SCIQLOP_VISUALIZATIONGRAPHHELPER_H
1 #ifndef SCIQLOP_VISUALIZATIONGRAPHHELPER_H
2 #define SCIQLOP_VISUALIZATIONGRAPHHELPER_H
2 #define SCIQLOP_VISUALIZATIONGRAPHHELPER_H
3
3
4 #include <Data/SqpRange.h>
4 #include <Data/SqpRange.h>
5
5
6 #include <QLoggingCategory>
6 #include <QLoggingCategory>
7 #include <QVector>
7 #include <QVector>
8
8
9 #include <memory>
9 #include <memory>
10
10
11 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphHelper)
11 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphHelper)
12
12
13 class IDataSeries;
13 class IDataSeries;
14 class QCPAbstractPlottable;
14 class QCPAbstractPlottable;
15 class QCustomPlot;
15 class QCustomPlot;
16 class Variable;
16 class Variable;
17
17
18 /**
18 /**
19 * @brief The VisualizationGraphHelper class aims to create the QCustomPlot components relative to a
19 * @brief The VisualizationGraphHelper class aims to create the QCustomPlot components relative to a
20 * variable, depending on the data series of this variable
20 * variable, depending on the data series of this variable
21 */
21 */
22 struct VisualizationGraphHelper {
22 struct VisualizationGraphHelper {
23 /**
23 /**
24 * Creates (if possible) the QCustomPlot components relative to the variable passed in
24 * Creates (if possible) the QCustomPlot components relative to the variable passed in
25 * parameter, and adds these to the plot passed in parameter.
25 * parameter, and adds these to the plot passed in parameter.
26 * @param variable the variable for which to create the components
26 * @param variable the variable for which to create the components
27 * @param plot the plot in which to add the created components. It takes ownership of these
27 * @param plot the plot in which to add the created components. It takes ownership of these
28 * components.
28 * components.
29 * @return the list of the components created
29 * @return the list of the components created
30 */
30 */
31 static QVector<QCPAbstractPlottable *> create(std::shared_ptr<Variable> variable,
31 static QVector<QCPAbstractPlottable *> create(std::shared_ptr<Variable> variable,
32 QCustomPlot &plot) noexcept;
32 QCustomPlot &plot) noexcept;
33 static QVector<QCPAbstractPlottable *> createV2(std::shared_ptr<Variable> variable,
34 QCustomPlot &plot) noexcept;
33
35
34 static void updateData(QVector<QCPAbstractPlottable *> plotableVect,
36 static void updateData(QVector<QCPAbstractPlottable *> plotableVect,
35 std::shared_ptr<IDataSeries> dataSeries, const SqpRange &dateTime);
37 std::shared_ptr<IDataSeries> dataSeries, const SqpRange &dateTime);
36 };
38 };
37
39
38 #endif // SCIQLOP_VISUALIZATIONGRAPHHELPER_H
40 #endif // SCIQLOP_VISUALIZATIONGRAPHHELPER_H
Show file before | Show file after | Hide comments
@@ -1,83 +1,84
1 #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
1 #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
2 #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
2 #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
3
3
4 #include "Visualization/IVisualizationWidget.h"
4 #include "Visualization/IVisualizationWidget.h"
5
5
6 #include <QLoggingCategory>
6 #include <QLoggingCategory>
7 #include <QWidget>
7 #include <QWidget>
8
8
9 #include <memory>
9 #include <memory>
10
10
11 #include <Common/spimpl.h>
11 #include <Common/spimpl.h>
12
12
13 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
13 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
14
14
15 class QCPRange;
15 class QCPRange;
16 class SqpRange;
16 class SqpRange;
17 class Variable;
17 class Variable;
18
18
19 namespace Ui {
19 namespace Ui {
20 class VisualizationGraphWidget;
20 class VisualizationGraphWidget;
21 } // namespace Ui
21 } // namespace Ui
22
22
23 class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
23 class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
24 Q_OBJECT
24 Q_OBJECT
25
25
26 public:
26 public:
27 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
27 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
28 virtual ~VisualizationGraphWidget();
28 virtual ~VisualizationGraphWidget();
29
29
30 /// If acquisition isn't enable, requestDataLoading signal cannot be emit
30 /// If acquisition isn't enable, requestDataLoading signal cannot be emit
31 void enableAcquisition(bool enable);
31 void enableAcquisition(bool enable);
32
32
33 void addVariable(std::shared_ptr<Variable> variable);
33 void addVariable(std::shared_ptr<Variable> variable, SqpRange range);
34 void addVariableUsingGraph(std::shared_ptr<Variable> variable);
34
35 /// Removes a variable from the graph
35 /// Removes a variable from the graph
36 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
36 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
37
37
38 void setRange(std::shared_ptr<Variable> variable, const SqpRange &range);
38 void setRange(std::shared_ptr<Variable> variable, const SqpRange &range);
39 void setYRange(const SqpRange &range);
39 SqpRange graphRange() const noexcept;
40 SqpRange graphRange() const noexcept;
40 void setGraphRange(const SqpRange &range);
41 void setGraphRange(const SqpRange &range);
41
42
42 // IVisualizationWidget interface
43 // IVisualizationWidget interface
43 void accept(IVisualizationWidgetVisitor *visitor) override;
44 void accept(IVisualizationWidgetVisitor *visitor) override;
44 bool canDrop(const Variable &variable) const override;
45 bool canDrop(const Variable &variable) const override;
45 bool contains(const Variable &variable) const override;
46 bool contains(const Variable &variable) const override;
46 QString name() const override;
47 QString name() const override;
47
48
48
49
49 signals:
50 signals:
50 void synchronize(const SqpRange &range, const SqpRange &oldRange);
51 void synchronize(const SqpRange &range, const SqpRange &oldRange);
51 void requestDataLoading(QVector<std::shared_ptr<Variable> > variable, const SqpRange &range,
52 void requestDataLoading(QVector<std::shared_ptr<Variable> > variable, const SqpRange &range,
52 const SqpRange &oldRange, bool synchronise);
53 const SqpRange &oldRange, bool synchronise);
53
54
54
55
55 void variableAdded(std::shared_ptr<Variable> var);
56 void variableAdded(std::shared_ptr<Variable> var);
56
57
57
58
58 private:
59 private:
59 Ui::VisualizationGraphWidget *ui;
60 Ui::VisualizationGraphWidget *ui;
60
61
61 class VisualizationGraphWidgetPrivate;
62 class VisualizationGraphWidgetPrivate;
62 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
63 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
63
64
64 private slots:
65 private slots:
65 /// Slot called when right clicking on the graph (displays a menu)
66 /// Slot called when right clicking on the graph (displays a menu)
66 void onGraphMenuRequested(const QPoint &pos) noexcept;
67 void onGraphMenuRequested(const QPoint &pos) noexcept;
67
68
68 /// Rescale the X axe to range parameter
69 /// Rescale the X axe to range parameter
69 void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
70 void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
70
71
71 /// Slot called when a mouse move was made
72 /// Slot called when a mouse move was made
72 void onMouseMove(QMouseEvent *event) noexcept;
73 void onMouseMove(QMouseEvent *event) noexcept;
73 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
74 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
74 void onMouseWheel(QWheelEvent *event) noexcept;
75 void onMouseWheel(QWheelEvent *event) noexcept;
75 /// Slot called when a mouse press was made, to activate the calibration of a graph
76 /// Slot called when a mouse press was made, to activate the calibration of a graph
76 void onMousePress(QMouseEvent *event) noexcept;
77 void onMousePress(QMouseEvent *event) noexcept;
77 /// Slot called when a mouse release was made, to deactivate the calibration of a graph
78 /// Slot called when a mouse release was made, to deactivate the calibration of a graph
78 void onMouseRelease(QMouseEvent *event) noexcept;
79 void onMouseRelease(QMouseEvent *event) noexcept;
79
80
80 void onDataCacheVariableUpdated();
81 void onDataCacheVariableUpdated();
81 };
82 };
82
83
83 #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
84 #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
Show file before | Show file after | Hide comments
@@ -1,163 +1,210
1 #include "Visualization/VisualizationGraphHelper.h"
1 #include "Visualization/VisualizationGraphHelper.h"
2 #include "Visualization/qcustomplot.h"
2 #include "Visualization/qcustomplot.h"
3
3
4 #include <Data/ScalarSeries.h>
4 #include <Data/ScalarSeries.h>
5
5
6 #include <Variable/Variable.h>
6 #include <Variable/Variable.h>
7
7
8 Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
8 Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
9
9
10 namespace {
10 namespace {
11
11
12 class SqpDataContainer : public QCPGraphDataContainer {
12 class SqpDataContainer : public QCPGraphDataContainer {
13 public:
13 public:
14 void appendGraphData(const QCPGraphData &data) { mData.append(data); }
14 void appendGraphData(const QCPGraphData &data) { mData.append(data); }
15 };
15 };
16
16
17
17
18 /// Format for datetimes on a axis
18 /// Format for datetimes on a axis
19 const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
19 const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
20
20
21 /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
21 /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
22 /// non-time data
22 /// non-time data
23 QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
23 QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
24 {
24 {
25 if (isTimeAxis) {
25 if (isTimeAxis) {
26 auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
26 auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
27 dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
27 dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
28 dateTicker->setDateTimeSpec(Qt::UTC);
28 dateTicker->setDateTimeSpec(Qt::UTC);
29
29
30 return dateTicker;
30 return dateTicker;
31 }
31 }
32 else {
32 else {
33 // default ticker
33 // default ticker
34 return QSharedPointer<QCPAxisTicker>::create();
34 return QSharedPointer<QCPAxisTicker>::create();
35 }
35 }
36 }
36 }
37
37
38 void updateScalarData(QCPAbstractPlottable *component, std::shared_ptr<ScalarSeries> scalarSeries,
38 void updateScalarData(QCPAbstractPlottable *component, std::shared_ptr<ScalarSeries> scalarSeries,
39 const SqpRange &dateTime)
39 const SqpRange &dateTime)
40 {
40 {
41 qCDebug(LOG_VisualizationGraphHelper()) << "TORM: updateScalarData"
41 qCDebug(LOG_VisualizationGraphHelper()) << "TORM: updateScalarData"
42 << QThread::currentThread()->objectName();
42 << QThread::currentThread()->objectName();
43 if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
43 if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
44 scalarSeries->lockRead();
44 scalarSeries->lockRead();
45 {
45 {
46 const auto &xData = scalarSeries->xAxisData()->cdata();
46 const auto &xData = scalarSeries->xAxisData()->cdata();
47 const auto &valuesData = scalarSeries->valuesData()->cdata();
47 const auto &valuesData = scalarSeries->valuesData()->cdata();
48
48
49 auto xDataBegin = xData.cbegin();
49 auto xDataBegin = xData.cbegin();
50 auto xDataEnd = xData.cend();
50 auto xDataEnd = xData.cend();
51
51
52 qCInfo(LOG_VisualizationGraphHelper()) << "TODEBUG: Current points in cache"
52 qCInfo(LOG_VisualizationGraphHelper()) << "TODEBUG: Current points in cache"
53 << xData.count();
53 << xData.count();
54
54
55 auto sqpDataContainer = QSharedPointer<SqpDataContainer>::create();
55 auto sqpDataContainer = QSharedPointer<SqpDataContainer>::create();
56 qcpGraph->setData(sqpDataContainer);
56 qcpGraph->setData(sqpDataContainer);
57
57
58 auto lowerIt = std::lower_bound(xDataBegin, xDataEnd, dateTime.m_TStart);
58 auto lowerIt = std::lower_bound(xDataBegin, xDataEnd, dateTime.m_TStart);
59 auto upperIt = std::upper_bound(xDataBegin, xDataEnd, dateTime.m_TEnd);
59 auto upperIt = std::upper_bound(xDataBegin, xDataEnd, dateTime.m_TEnd);
60 auto distance = std::distance(xDataBegin, lowerIt);
60 auto distance = std::distance(xDataBegin, lowerIt);
61
61
62 auto valuesDataIt = valuesData.cbegin() + distance;
62 auto valuesDataIt = valuesData.cbegin() + distance;
63 for (auto xAxisDataIt = lowerIt; xAxisDataIt != upperIt;
63 for (auto xAxisDataIt = lowerIt; xAxisDataIt != upperIt;
64 ++xAxisDataIt, ++valuesDataIt) {
64 ++xAxisDataIt, ++valuesDataIt) {
65 sqpDataContainer->appendGraphData(QCPGraphData(*xAxisDataIt, *valuesDataIt));
65 sqpDataContainer->appendGraphData(QCPGraphData(*xAxisDataIt, *valuesDataIt));
66 }
66 }
67
67
68 qCInfo(LOG_VisualizationGraphHelper()) << "TODEBUG: Current points displayed"
68 qCInfo(LOG_VisualizationGraphHelper()) << "TODEBUG: Current points displayed"
69 << sqpDataContainer->size();
69 << sqpDataContainer->size();
70 }
70 }
71 scalarSeries->unlock();
71 scalarSeries->unlock();
72
72
73
73
74 // Display all data
74 // Display all data
75 component->parentPlot()->replot();
75 component->parentPlot()->replot();
76 }
76 }
77 else {
77 else {
78 /// @todo DEBUG
78 /// @todo DEBUG
79 }
79 }
80 }
80 }
81
81
82 QCPAbstractPlottable *createScalarSeriesComponentV2(std::shared_ptr<ScalarSeries> scalarSeries,
83 QCustomPlot &plot)
84 {
85 auto component = plot.addGraph();
86
87 if (component) {
88 // Axes properties
89 /// @todo : for the moment, no control is performed on the axes: the units and the tickers
90 /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
91
92 auto setAxisProperties = [](auto axis, const auto &unit) {
93 // label (unit name)
94 axis->setLabel(unit.m_Name);
95
96 // ticker (depending on the type of unit)
97 axis->setTicker(axisTicker(unit.m_TimeUnit));
98 };
99 setAxisProperties(plot.xAxis, scalarSeries->xAxisUnit());
100 setAxisProperties(plot.yAxis, scalarSeries->valuesUnit());
101 }
102 return component;
103 }
104
82 QCPAbstractPlottable *createScalarSeriesComponent(std::shared_ptr<ScalarSeries> scalarSeries,
105 QCPAbstractPlottable *createScalarSeriesComponent(std::shared_ptr<ScalarSeries> scalarSeries,
83 QCustomPlot &plot, const SqpRange &dateTime)
106 QCustomPlot &plot, const SqpRange &dateTime)
84 {
107 {
85 auto component = plot.addGraph();
108 auto component = plot.addGraph();
86
109
87 if (component) {
110 if (component) {
88 // // Graph data
111 // // Graph data
89 component->setData(scalarSeries->xAxisData()->data(), scalarSeries->valuesData()->data(),
112 component->setData(scalarSeries->xAxisData()->data(), scalarSeries->valuesData()->data(),
90 true);
113 true);
91
114
92 updateScalarData(component, scalarSeries, dateTime);
115 updateScalarData(component, scalarSeries, dateTime);
93
116
94 // Axes properties
117 // Axes properties
95 /// @todo : for the moment, no control is performed on the axes: the units and the tickers
118 /// @todo : for the moment, no control is performed on the axes: the units and the tickers
96 /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
119 /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
97
120
98 auto setAxisProperties = [](auto axis, const auto &unit) {
121 auto setAxisProperties = [](auto axis, const auto &unit) {
99 // label (unit name)
122 // label (unit name)
100 axis->setLabel(unit.m_Name);
123 axis->setLabel(unit.m_Name);
101
124
102 // ticker (depending on the type of unit)
125 // ticker (depending on the type of unit)
103 axis->setTicker(axisTicker(unit.m_TimeUnit));
126 axis->setTicker(axisTicker(unit.m_TimeUnit));
104 };
127 };
105 setAxisProperties(plot.xAxis, scalarSeries->xAxisUnit());
128 setAxisProperties(plot.xAxis, scalarSeries->xAxisUnit());
106 setAxisProperties(plot.yAxis, scalarSeries->valuesUnit());
129 setAxisProperties(plot.yAxis, scalarSeries->valuesUnit());
107
130
108 // Display all data
131 // Display all data
109 component->rescaleAxes();
132 component->rescaleAxes();
110 plot.replot();
133 plot.replot();
111 }
134 }
112 else {
135 else {
113 qCDebug(LOG_VisualizationGraphHelper())
136 qCDebug(LOG_VisualizationGraphHelper())
114 << QObject::tr("Can't create graph for the scalar series");
137 << QObject::tr("Can't create graph for the scalar series");
115 }
138 }
116
139
117 return component;
140 return component;
118 }
141 }
119
142
120 } // namespace
143 } // namespace
121
144
145 QVector<QCPAbstractPlottable *>
146 VisualizationGraphHelper::createV2(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept
147 {
148 auto result = QVector<QCPAbstractPlottable *>{};
149
150 if (variable) {
151 // Gets the data series of the variable to call the creation of the right components
152 // according to its type
153 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(variable->dataSeries())) {
154 result.append(createScalarSeriesComponentV2(scalarSeries, plot));
155 }
156 else {
157 qCDebug(LOG_VisualizationGraphHelper())
158 << QObject::tr("Can't create graph plottables : unmanaged data series type");
159 }
160 }
161 else {
162 qCDebug(LOG_VisualizationGraphHelper())
163 << QObject::tr("Can't create graph plottables : the variable is null");
164 }
165
166 return result;
167 }
168
122 QVector<QCPAbstractPlottable *> VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
169 QVector<QCPAbstractPlottable *> VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
123 QCustomPlot &plot) noexcept
170 QCustomPlot &plot) noexcept
124 {
171 {
125 auto result = QVector<QCPAbstractPlottable *>{};
172 auto result = QVector<QCPAbstractPlottable *>{};
126
173
127 if (variable) {
174 if (variable) {
128 // Gets the data series of the variable to call the creation of the right components
175 // Gets the data series of the variable to call the creation of the right components
129 // according to its type
176 // according to its type
130 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(variable->dataSeries())) {
177 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(variable->dataSeries())) {
131 result.append(createScalarSeriesComponent(scalarSeries, plot, variable->range()));
178 result.append(createScalarSeriesComponent(scalarSeries, plot, variable->range()));
132 }
179 }
133 else {
180 else {
134 qCDebug(LOG_VisualizationGraphHelper())
181 qCDebug(LOG_VisualizationGraphHelper())
135 << QObject::tr("Can't create graph plottables : unmanaged data series type");
182 << QObject::tr("Can't create graph plottables : unmanaged data series type");
136 }
183 }
137 }
184 }
138 else {
185 else {
139 qCDebug(LOG_VisualizationGraphHelper())
186 qCDebug(LOG_VisualizationGraphHelper())
140 << QObject::tr("Can't create graph plottables : the variable is null");
187 << QObject::tr("Can't create graph plottables : the variable is null");
141 }
188 }
142
189
143 return result;
190 return result;
144 }
191 }
145
192
146 void VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *> plotableVect,
193 void VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *> plotableVect,
147 std::shared_ptr<IDataSeries> dataSeries,
194 std::shared_ptr<IDataSeries> dataSeries,
148 const SqpRange &dateTime)
195 const SqpRange &dateTime)
149 {
196 {
150 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
197 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
151 if (plotableVect.size() == 1) {
198 if (plotableVect.size() == 1) {
152 updateScalarData(plotableVect.at(0), scalarSeries, dateTime);
199 updateScalarData(plotableVect.at(0), scalarSeries, dateTime);
153 }
200 }
154 else {
201 else {
155 qCCritical(LOG_VisualizationGraphHelper()) << QObject::tr(
202 qCCritical(LOG_VisualizationGraphHelper()) << QObject::tr(
156 "Can't update Data of a scalarSeries because there is not only one component "
203 "Can't update Data of a scalarSeries because there is not only one component "
157 "associated");
204 "associated");
158 }
205 }
159 }
206 }
160 else {
207 else {
161 /// @todo DEBUG
208 /// @todo DEBUG
162 }
209 }
163 }
210 }
Show file before | Show file after | Hide comments
@@ -1,307 +1,307
1 #include "Visualization/VisualizationGraphWidget.h"
1 #include "Visualization/VisualizationGraphWidget.h"
2 #include "Visualization/IVisualizationWidgetVisitor.h"
2 #include "Visualization/IVisualizationWidgetVisitor.h"
3 #include "Visualization/VisualizationGraphHelper.h"
3 #include "Visualization/VisualizationGraphHelper.h"
4 #include "Visualization/VisualizationGraphRenderingDelegate.h"
4 #include "Visualization/VisualizationGraphRenderingDelegate.h"
5 #include "ui_VisualizationGraphWidget.h"
5 #include "ui_VisualizationGraphWidget.h"
6
6
7 #include <Data/ArrayData.h>
7 #include <Data/ArrayData.h>
8 #include <Data/IDataSeries.h>
8 #include <Data/IDataSeries.h>
9 #include <Settings/SqpSettingsDefs.h>
9 #include <Settings/SqpSettingsDefs.h>
10 #include <SqpApplication.h>
10 #include <SqpApplication.h>
11 #include <Variable/Variable.h>
11 #include <Variable/Variable.h>
12 #include <Variable/VariableController.h>
12 #include <Variable/VariableController.h>
13
13
14 #include <unordered_map>
14 #include <unordered_map>
15
15
16 Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
16 Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
17
17
18 namespace {
18 namespace {
19
19
20 /// Key pressed to enable zoom on horizontal axis
20 /// Key pressed to enable zoom on horizontal axis
21 const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
21 const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
22
22
23 /// Key pressed to enable zoom on vertical axis
23 /// Key pressed to enable zoom on vertical axis
24 const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
24 const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
25
25
26 } // namespace
26 } // namespace
27
27
28 struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
28 struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
29
29
30 explicit VisualizationGraphWidgetPrivate()
30 explicit VisualizationGraphWidgetPrivate()
31 : m_DoAcquisition{true}, m_IsCalibration{false}, m_RenderingDelegate{nullptr}
31 : m_DoAcquisition{true}, m_IsCalibration{false}, m_RenderingDelegate{nullptr}
32 {
32 {
33 }
33 }
34
34
35 // 1 variable -> n qcpplot
35 // 1 variable -> n qcpplot
36 std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
36 std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
37 bool m_DoAcquisition;
37 bool m_DoAcquisition;
38 bool m_IsCalibration;
38 bool m_IsCalibration;
39 QCPItemTracer *m_TextTracer;
39 QCPItemTracer *m_TextTracer;
40 /// Delegate used to attach rendering features to the plot
40 /// Delegate used to attach rendering features to the plot
41 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
41 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
42 };
42 };
43
43
44 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
44 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
45 : QWidget{parent},
45 : QWidget{parent},
46 ui{new Ui::VisualizationGraphWidget},
46 ui{new Ui::VisualizationGraphWidget},
47 impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
47 impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
48 {
48 {
49 ui->setupUi(this);
49 ui->setupUi(this);
50
50
51 // The delegate must be initialized after the ui as it uses the plot
51 // The delegate must be initialized after the ui as it uses the plot
52 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*ui->widget);
52 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*ui->widget);
53
53
54 ui->graphNameLabel->setText(name);
54 ui->graphNameLabel->setText(name);
55
55
56 // 'Close' options : widget is deleted when closed
56 // 'Close' options : widget is deleted when closed
57 setAttribute(Qt::WA_DeleteOnClose);
57 setAttribute(Qt::WA_DeleteOnClose);
58 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationGraphWidget::close);
58 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationGraphWidget::close);
59 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
59 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
60
60
61 // Set qcpplot properties :
61 // Set qcpplot properties :
62 // - Drag (on x-axis) and zoom are enabled
62 // - Drag (on x-axis) and zoom are enabled
63 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
63 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
64 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
64 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
65 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
65 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
66
66
67 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
67 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
68 connect(ui->widget, &QCustomPlot::mouseRelease, this,
68 connect(ui->widget, &QCustomPlot::mouseRelease, this,
69 &VisualizationGraphWidget::onMouseRelease);
69 &VisualizationGraphWidget::onMouseRelease);
70 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
70 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
71 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
71 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
72 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
72 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
73 &QCPAxis::rangeChanged),
73 &QCPAxis::rangeChanged),
74 this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
74 this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
75
75
76 // Activates menu when right clicking on the graph
76 // Activates menu when right clicking on the graph
77 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
77 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
78 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
78 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
79 &VisualizationGraphWidget::onGraphMenuRequested);
79 &VisualizationGraphWidget::onGraphMenuRequested);
80
80
81 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
81 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
82 &VariableController::onRequestDataLoading);
82 &VariableController::onRequestDataLoading);
83 }
83 }
84
84
85
85
86 VisualizationGraphWidget::~VisualizationGraphWidget()
86 VisualizationGraphWidget::~VisualizationGraphWidget()
87 {
87 {
88 delete ui;
88 delete ui;
89 }
89 }
90
90
91 void VisualizationGraphWidget::enableAcquisition(bool enable)
91 void VisualizationGraphWidget::enableAcquisition(bool enable)
92 {
92 {
93 impl->m_DoAcquisition = enable;
93 impl->m_DoAcquisition = enable;
94 }
94 }
95
95
96 void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
96 void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
97 {
97 {
98 auto calibrationState = impl->m_IsCalibration;
99 impl->m_IsCalibration = true;
100 // Uses delegate to create the qcpplot components according to the variable
98 // Uses delegate to create the qcpplot components according to the variable
101 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
99 auto createdPlottables = VisualizationGraphHelper::createV2(variable, *ui->widget);
102 impl->m_IsCalibration = calibrationState;
103
100
104 for (auto createdPlottable : qAsConst(createdPlottables)) {
101 for (auto createdPlottable : qAsConst(createdPlottables)) {
105 impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
102 impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
106 }
103 }
107
104
108 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
105 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
109
106
110 emit variableAdded(variable);
107 auto varRange = variable->range();
111 }
112 void VisualizationGraphWidget::addVariableUsingGraph(std::shared_ptr<Variable> variable)
113 {
114 // Uses delegate to create the qcpplot components according to the variable
115 this->addVariable(variable);
116
108
117 // Request range for the variable
109 this->enableAcquisition(false);
118 auto graphRange = ui->widget->xAxis->range();
110 this->setGraphRange(range);
111 this->enableAcquisition(true);
119
112
120 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable,
113 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, varRange,
121 SqpRange{graphRange.lower, graphRange.upper}, variable->range(), false);
114 false);
115
116 emit variableAdded(variable);
122 }
117 }
123
118
124 void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
119 void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
125 {
120 {
126 // Each component associated to the variable :
121 // Each component associated to the variable :
127 // - is removed from qcpplot (which deletes it)
122 // - is removed from qcpplot (which deletes it)
128 // - is no longer referenced in the map
123 // - is no longer referenced in the map
129 auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
124 auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
130 for (auto it = componentsIt.first; it != componentsIt.second;) {
125 for (auto it = componentsIt.first; it != componentsIt.second;) {
131 ui->widget->removePlottable(it->second);
126 ui->widget->removePlottable(it->second);
132 it = impl->m_VariableToPlotMultiMap.erase(it);
127 it = impl->m_VariableToPlotMultiMap.erase(it);
133 }
128 }
134
129
135 // Updates graph
130 // Updates graph
136 ui->widget->replot();
131 ui->widget->replot();
137 }
132 }
138
133
139 void VisualizationGraphWidget::setRange(std::shared_ptr<Variable> variable, const SqpRange &range)
134 void VisualizationGraphWidget::setRange(std::shared_ptr<Variable> variable, const SqpRange &range)
140 {
135 {
141 // Note: in case of different axes that depends on variable, we could start with a code like
136 // Note: in case of different axes that depends on variable, we could start with a code like
142 // that:
137 // that:
143 // auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
138 // auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
144 // for (auto it = componentsIt.first; it != componentsIt.second;) {
139 // for (auto it = componentsIt.first; it != componentsIt.second;) {
145 // }
140 // }
146 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
141 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
147 ui->widget->replot();
142 ui->widget->replot();
148 }
143 }
149
144
145 void VisualizationGraphWidget::setYRange(const SqpRange &range)
146 {
147 ui->widget->yAxis->setRange(range.m_TStart, range.m_TEnd);
148 }
149
150 SqpRange VisualizationGraphWidget::graphRange() const noexcept
150 SqpRange VisualizationGraphWidget::graphRange() const noexcept
151 {
151 {
152 auto graphRange = ui->widget->xAxis->range();
152 auto graphRange = ui->widget->xAxis->range();
153 return SqpRange{graphRange.lower, graphRange.upper};
153 return SqpRange{graphRange.lower, graphRange.upper};
154 }
154 }
155
155
156 void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
156 void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
157 {
157 {
158 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
158 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
159 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
159 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
160 ui->widget->replot();
160 ui->widget->replot();
161 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
161 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
162 }
162 }
163
163
164 void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
164 void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
165 {
165 {
166 if (visitor) {
166 if (visitor) {
167 visitor->visit(this);
167 visitor->visit(this);
168 }
168 }
169 else {
169 else {
170 qCCritical(LOG_VisualizationGraphWidget())
170 qCCritical(LOG_VisualizationGraphWidget())
171 << tr("Can't visit widget : the visitor is null");
171 << tr("Can't visit widget : the visitor is null");
172 }
172 }
173 }
173 }
174
174
175 bool VisualizationGraphWidget::canDrop(const Variable &variable) const
175 bool VisualizationGraphWidget::canDrop(const Variable &variable) const
176 {
176 {
177 /// @todo : for the moment, a graph can always accomodate a variable
177 /// @todo : for the moment, a graph can always accomodate a variable
178 Q_UNUSED(variable);
178 Q_UNUSED(variable);
179 return true;
179 return true;
180 }
180 }
181
181
182 bool VisualizationGraphWidget::contains(const Variable &variable) const
182 bool VisualizationGraphWidget::contains(const Variable &variable) const
183 {
183 {
184 // Finds the variable among the keys of the map
184 // Finds the variable among the keys of the map
185 auto variablePtr = &variable;
185 auto variablePtr = &variable;
186 auto findVariable
186 auto findVariable
187 = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
187 = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
188
188
189 auto end = impl->m_VariableToPlotMultiMap.cend();
189 auto end = impl->m_VariableToPlotMultiMap.cend();
190 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
190 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
191 return it != end;
191 return it != end;
192 }
192 }
193
193
194 QString VisualizationGraphWidget::name() const
194 QString VisualizationGraphWidget::name() const
195 {
195 {
196 return ui->graphNameLabel->text();
196 return ui->graphNameLabel->text();
197 }
197 }
198
198
199 void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
199 void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
200 {
200 {
201 QMenu graphMenu{};
201 QMenu graphMenu{};
202
202
203 // Iterates on variables (unique keys)
203 // Iterates on variables (unique keys)
204 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
204 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
205 end = impl->m_VariableToPlotMultiMap.cend();
205 end = impl->m_VariableToPlotMultiMap.cend();
206 it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
206 it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
207 // 'Remove variable' action
207 // 'Remove variable' action
208 graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
208 graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
209 [ this, var = it->first ]() { removeVariable(var); });
209 [ this, var = it->first ]() { removeVariable(var); });
210 }
210 }
211
211
212 if (!graphMenu.isEmpty()) {
212 if (!graphMenu.isEmpty()) {
213 graphMenu.exec(mapToGlobal(pos));
213 graphMenu.exec(mapToGlobal(pos));
214 }
214 }
215 }
215 }
216
216
217 void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
217 void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
218 {
218 {
219 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
219 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
220 << QThread::currentThread()->objectName() << "DoAcqui"
220 << QThread::currentThread()->objectName() << "DoAcqui"
221 << impl->m_DoAcquisition;
221 << impl->m_DoAcquisition;
222
222
223 auto graphRange = SqpRange{t1.lower, t1.upper};
223 auto graphRange = SqpRange{t1.lower, t1.upper};
224 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
224 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
225
225
226 if (impl->m_DoAcquisition) {
226 if (impl->m_DoAcquisition) {
227 QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
227 QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
228
228
229 for (auto it = impl->m_VariableToPlotMultiMap.begin(),
229 for (auto it = impl->m_VariableToPlotMultiMap.begin(),
230 end = impl->m_VariableToPlotMultiMap.end();
230 end = impl->m_VariableToPlotMultiMap.end();
231 it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
231 it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
232 variableUnderGraphVector.push_back(it->first);
232 variableUnderGraphVector.push_back(it->first);
233 }
233 }
234 emit requestDataLoading(std::move(variableUnderGraphVector), graphRange, oldGraphRange,
234 emit requestDataLoading(std::move(variableUnderGraphVector), graphRange, oldGraphRange,
235 !impl->m_IsCalibration);
235 !impl->m_IsCalibration);
236
236
237 if (!impl->m_IsCalibration) {
237 if (!impl->m_IsCalibration) {
238 qCDebug(LOG_VisualizationGraphWidget())
238 qCDebug(LOG_VisualizationGraphWidget())
239 << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
239 << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
240 << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
240 << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
241 emit synchronize(graphRange, oldGraphRange);
241 emit synchronize(graphRange, oldGraphRange);
242 }
242 }
243 }
243 }
244 }
244 }
245
245
246 void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
246 void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
247 {
247 {
248 // Handles plot rendering when mouse is moving
248 // Handles plot rendering when mouse is moving
249 impl->m_RenderingDelegate->onMouseMove(event);
249 impl->m_RenderingDelegate->onMouseMove(event);
250 }
250 }
251
251
252 void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
252 void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
253 {
253 {
254 auto zoomOrientations = QFlags<Qt::Orientation>{};
254 auto zoomOrientations = QFlags<Qt::Orientation>{};
255
255
256 // Lambda that enables a zoom orientation if the key modifier related to this orientation
256 // Lambda that enables a zoom orientation if the key modifier related to this orientation
257 // has
257 // has
258 // been pressed
258 // been pressed
259 auto enableOrientation
259 auto enableOrientation
260 = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
260 = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
261 auto orientationEnabled = event->modifiers().testFlag(modifier);
261 auto orientationEnabled = event->modifiers().testFlag(modifier);
262 zoomOrientations.setFlag(orientation, orientationEnabled);
262 zoomOrientations.setFlag(orientation, orientationEnabled);
263 };
263 };
264 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
264 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
265 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
265 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
266
266
267 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
267 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
268 }
268 }
269
269
270 void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
270 void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
271 {
271 {
272 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
272 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
273 }
273 }
274
274
275 void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
275 void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
276 {
276 {
277 impl->m_IsCalibration = false;
277 impl->m_IsCalibration = false;
278 }
278 }
279
279
280 void VisualizationGraphWidget::onDataCacheVariableUpdated()
280 void VisualizationGraphWidget::onDataCacheVariableUpdated()
281 {
281 {
282 // NOTE:
282 // NOTE:
283 // We don't want to call the method for each component of a variable unitarily, but for
283 // We don't want to call the method for each component of a variable unitarily, but for
284 // all
284 // all
285 // its components at once (eg its three components in the case of a vector).
285 // its components at once (eg its three components in the case of a vector).
286
286
287 // The unordered_multimap does not do this easily, so the question is whether to:
287 // The unordered_multimap does not do this easily, so the question is whether to:
288 // - use an ordered_multimap and the algos of std to group the values by key
288 // - use an ordered_multimap and the algos of std to group the values by key
289 // - use a map (unique keys) and store as values directly the list of components
289 // - use a map (unique keys) and store as values directly the list of components
290
290
291 auto graphRange = ui->widget->xAxis->range();
291 auto graphRange = ui->widget->xAxis->range();
292 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
292 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
293
293
294 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
294 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
295 it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
295 it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
296 auto variable = it->first;
296 auto variable = it->first;
297 qCDebug(LOG_VisualizationGraphWidget())
297 qCDebug(LOG_VisualizationGraphWidget())
298 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
298 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
299 qCDebug(LOG_VisualizationGraphWidget())
299 qCDebug(LOG_VisualizationGraphWidget())
300 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
300 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
301 if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
301 if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
302
302
303 VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
303 VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
304 variable->dataSeries(), variable->range());
304 variable->dataSeries(), variable->range());
305 }
305 }
306 }
306 }
307 }
307 }
Show file before | Show file after | Hide comments
@@ -1,225 +1,244
1 #include "Visualization/VisualizationZoneWidget.h"
1 #include "Visualization/VisualizationZoneWidget.h"
2
2
3
3
4 #include "Visualization/IVisualizationWidgetVisitor.h"
4 #include "Visualization/IVisualizationWidgetVisitor.h"
5 #include "Visualization/VisualizationGraphWidget.h"
5 #include "Visualization/VisualizationGraphWidget.h"
6 #include "ui_VisualizationZoneWidget.h"
6 #include "ui_VisualizationZoneWidget.h"
7
7
8 #include <Data/SqpRange.h>
8 #include <Data/SqpRange.h>
9 #include <Variable/Variable.h>
9 #include <Variable/VariableController.h>
10 #include <Variable/VariableController.h>
10
11
11 #include <QUuid>
12 #include <QUuid>
12 #include <SqpApplication.h>
13 #include <SqpApplication.h>
13
14
14 Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
15 Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
15
16
16 namespace {
17 namespace {
17
18
18 /// Minimum height for graph added in zones (in pixels)
19 /// Minimum height for graph added in zones (in pixels)
19 const auto GRAPH_MINIMUM_HEIGHT = 300;
20 const auto GRAPH_MINIMUM_HEIGHT = 300;
20
21
21 /// Generates a default name for a new graph, according to the number of graphs already displayed in
22 /// Generates a default name for a new graph, according to the number of graphs already displayed in
22 /// the zone
23 /// the zone
23 QString defaultGraphName(const QLayout &layout)
24 QString defaultGraphName(const QLayout &layout)
24 {
25 {
25 auto count = 0;
26 auto count = 0;
26 for (auto i = 0; i < layout.count(); ++i) {
27 for (auto i = 0; i < layout.count(); ++i) {
27 if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
28 if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
28 count++;
29 count++;
29 }
30 }
30 }
31 }
31
32
32 return QObject::tr("Graph %1").arg(count + 1);
33 return QObject::tr("Graph %1").arg(count + 1);
33 }
34 }
34
35
35 } // namespace
36 } // namespace
36
37
37 struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
38 struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
38
39
39 explicit VisualizationZoneWidgetPrivate() : m_SynchronisationGroupId{QUuid::createUuid()} {}
40 explicit VisualizationZoneWidgetPrivate() : m_SynchronisationGroupId{QUuid::createUuid()} {}
40 QUuid m_SynchronisationGroupId;
41 QUuid m_SynchronisationGroupId;
41 };
42 };
42
43
43 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
44 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
44 : QWidget{parent},
45 : QWidget{parent},
45 ui{new Ui::VisualizationZoneWidget},
46 ui{new Ui::VisualizationZoneWidget},
46 impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
47 impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
47 {
48 {
48 ui->setupUi(this);
49 ui->setupUi(this);
49
50
50 ui->zoneNameLabel->setText(name);
51 ui->zoneNameLabel->setText(name);
51
52
52 // 'Close' options : widget is deleted when closed
53 // 'Close' options : widget is deleted when closed
53 setAttribute(Qt::WA_DeleteOnClose);
54 setAttribute(Qt::WA_DeleteOnClose);
54 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
55 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
55 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
56 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
56
57
57 // Synchronisation id
58 // Synchronisation id
58 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
59 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
59 Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
60 Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
60 }
61 }
61
62
62 VisualizationZoneWidget::~VisualizationZoneWidget()
63 VisualizationZoneWidget::~VisualizationZoneWidget()
63 {
64 {
64 delete ui;
65 delete ui;
65 }
66 }
66
67
67 void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
68 void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
68 {
69 {
69 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
70 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
70 }
71 }
71
72
72 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
73 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
73 {
74 {
74 auto graphWidget = new VisualizationGraphWidget{
75 auto graphWidget = new VisualizationGraphWidget{
75 defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
76 defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
76
77
77
78
78 // Set graph properties
79 // Set graph properties
79 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
80 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
80 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
81 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
81
82
82
83
83 // Lambda to synchronize zone widget
84 // Lambda to synchronize zone widget
84 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
85 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
85 const SqpRange &oldGraphRange) {
86 const SqpRange &oldGraphRange) {
86
87
87 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
88 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
88 auto frameLayout = ui->visualizationZoneFrame->layout();
89 auto frameLayout = ui->visualizationZoneFrame->layout();
89 for (auto i = 0; i < frameLayout->count(); ++i) {
90 for (auto i = 0; i < frameLayout->count(); ++i) {
90 auto graphChild
91 auto graphChild
91 = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
92 = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
92 if (graphChild && (graphChild != graphWidget)) {
93 if (graphChild && (graphChild != graphWidget)) {
93
94
94 auto graphChildRange = graphChild->graphRange();
95 auto graphChildRange = graphChild->graphRange();
95 switch (zoomType) {
96 switch (zoomType) {
96 case AcquisitionZoomType::ZoomIn: {
97 case AcquisitionZoomType::ZoomIn: {
97 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
98 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
98 auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
99 auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
99 graphChildRange.m_TStart += deltaLeft;
100 graphChildRange.m_TStart += deltaLeft;
100 graphChildRange.m_TEnd -= deltaRight;
101 graphChildRange.m_TEnd -= deltaRight;
101 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
102 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
102 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
103 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
103 << deltaLeft;
104 << deltaLeft;
104 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
105 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
105 << deltaRight;
106 << deltaRight;
106 qCCritical(LOG_VisualizationZoneWidget())
107 qCCritical(LOG_VisualizationZoneWidget())
107 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
108 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
108
109
109 break;
110 break;
110 }
111 }
111
112
112 case AcquisitionZoomType::ZoomOut: {
113 case AcquisitionZoomType::ZoomOut: {
113 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
114 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
114 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
115 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
115 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
116 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
116 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
117 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
117 << deltaLeft;
118 << deltaLeft;
118 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
119 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
119 << deltaRight;
120 << deltaRight;
120 qCCritical(LOG_VisualizationZoneWidget())
121 qCCritical(LOG_VisualizationZoneWidget())
121 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
122 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
122 graphChildRange.m_TStart -= deltaLeft;
123 graphChildRange.m_TStart -= deltaLeft;
123 graphChildRange.m_TEnd += deltaRight;
124 graphChildRange.m_TEnd += deltaRight;
124 break;
125 break;
125 }
126 }
126 case AcquisitionZoomType::PanRight: {
127 case AcquisitionZoomType::PanRight: {
127 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
128 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
128 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
129 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
129 graphChildRange.m_TStart += deltaRight;
130 graphChildRange.m_TStart += deltaRight;
130 graphChildRange.m_TEnd += deltaRight;
131 graphChildRange.m_TEnd += deltaRight;
131 qCCritical(LOG_VisualizationZoneWidget())
132 qCCritical(LOG_VisualizationZoneWidget())
132 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
133 << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
133 break;
134 break;
134 }
135 }
135 case AcquisitionZoomType::PanLeft: {
136 case AcquisitionZoomType::PanLeft: {
136 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
137 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
137 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
138 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
138 graphChildRange.m_TStart -= deltaLeft;
139 graphChildRange.m_TStart -= deltaLeft;
139 graphChildRange.m_TEnd -= deltaLeft;
140 graphChildRange.m_TEnd -= deltaLeft;
140 break;
141 break;
141 }
142 }
142 case AcquisitionZoomType::Unknown: {
143 case AcquisitionZoomType::Unknown: {
143 qCCritical(LOG_VisualizationZoneWidget())
144 qCCritical(LOG_VisualizationZoneWidget())
144 << tr("Impossible to synchronize: zoom type unknown");
145 << tr("Impossible to synchronize: zoom type unknown");
145 break;
146 break;
146 }
147 }
147 default:
148 default:
148 qCCritical(LOG_VisualizationZoneWidget())
149 qCCritical(LOG_VisualizationZoneWidget())
149 << tr("Impossible to synchronize: zoom type not take into account");
150 << tr("Impossible to synchronize: zoom type not take into account");
150 // No action
151 // No action
151 break;
152 break;
152 }
153 }
153 graphChild->enableAcquisition(false);
154 graphChild->enableAcquisition(false);
154 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
155 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
155 << graphChild->graphRange();
156 << graphChild->graphRange();
156 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
157 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
157 << graphChildRange;
158 << graphChildRange;
158 qCCritical(LOG_VisualizationZoneWidget())
159 qCCritical(LOG_VisualizationZoneWidget())
159 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
160 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
160 graphChild->setGraphRange(graphChildRange);
161 graphChild->setGraphRange(graphChildRange);
161 graphChild->enableAcquisition(true);
162 graphChild->enableAcquisition(true);
162 }
163 }
163 }
164 }
164 };
165 };
165
166
166 // connection for synchronization
167 // connection for synchronization
167 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
168 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
168 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
169 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
169 &VisualizationZoneWidget::onVariableAdded);
170 &VisualizationZoneWidget::onVariableAdded);
170
171
172 auto range = SqpRange{};
173
174 // Apply visitor to graph children
175 auto layout = ui->visualizationZoneFrame->layout();
176 if (layout->count() > 0) {
177 // Case of a new graph in a existant zone
178 if (auto visualizationGraphWidget
179 = dynamic_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
180 range = visualizationGraphWidget->graphRange();
181 }
182 }
183 else {
184 // Case of a new graph as the first of the zone
185 range = variable->range();
186 }
187
171 this->addGraph(graphWidget);
188 this->addGraph(graphWidget);
172
189
173 graphWidget->addVariable(variable);
190 graphWidget->addVariable(variable, range);
191 // TODO: get y using variable range
192 graphWidget->setYRange(SqpRange{-10, 10});
174
193
175 return graphWidget;
194 return graphWidget;
176 }
195 }
177
196
178 void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
197 void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
179 {
198 {
180 if (visitor) {
199 if (visitor) {
181 visitor->visitEnter(this);
200 visitor->visitEnter(this);
182
201
183 // Apply visitor to graph children
202 // Apply visitor to graph children
184 auto layout = ui->visualizationZoneFrame->layout();
203 auto layout = ui->visualizationZoneFrame->layout();
185 for (auto i = 0; i < layout->count(); ++i) {
204 for (auto i = 0; i < layout->count(); ++i) {
186 if (auto item = layout->itemAt(i)) {
205 if (auto item = layout->itemAt(i)) {
187 // Widgets different from graphs are not visited (no action)
206 // Widgets different from graphs are not visited (no action)
188 if (auto visualizationGraphWidget
207 if (auto visualizationGraphWidget
189 = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
208 = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
190 visualizationGraphWidget->accept(visitor);
209 visualizationGraphWidget->accept(visitor);
191 }
210 }
192 }
211 }
193 }
212 }
194
213
195 visitor->visitLeave(this);
214 visitor->visitLeave(this);
196 }
215 }
197 else {
216 else {
198 qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
217 qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
199 }
218 }
200 }
219 }
201
220
202 bool VisualizationZoneWidget::canDrop(const Variable &variable) const
221 bool VisualizationZoneWidget::canDrop(const Variable &variable) const
203 {
222 {
204 // A tab can always accomodate a variable
223 // A tab can always accomodate a variable
205 Q_UNUSED(variable);
224 Q_UNUSED(variable);
206 return true;
225 return true;
207 }
226 }
208
227
209 bool VisualizationZoneWidget::contains(const Variable &variable) const
228 bool VisualizationZoneWidget::contains(const Variable &variable) const
210 {
229 {
211 Q_UNUSED(variable);
230 Q_UNUSED(variable);
212 return false;
231 return false;
213 }
232 }
214
233
215 QString VisualizationZoneWidget::name() const
234 QString VisualizationZoneWidget::name() const
216 {
235 {
217 return ui->zoneNameLabel->text();
236 return ui->zoneNameLabel->text();
218 }
237 }
219
238
220 void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
239 void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
221 {
240 {
222 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
241 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
223 Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
242 Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
224 Q_ARG(QUuid, impl->m_SynchronisationGroupId));
243 Q_ARG(QUuid, impl->m_SynchronisationGroupId));
225 }
244 }
Show file before | Show file after | Hide comments
@@ -1,200 +1,201
1 #include "Visualization/operations/GenerateVariableMenuOperation.h"
1 #include "Visualization/operations/GenerateVariableMenuOperation.h"
2 #include "Visualization/operations/MenuBuilder.h"
2 #include "Visualization/operations/MenuBuilder.h"
3
3
4 #include "Visualization/VisualizationGraphWidget.h"
4 #include "Visualization/VisualizationGraphWidget.h"
5 #include "Visualization/VisualizationTabWidget.h"
5 #include "Visualization/VisualizationTabWidget.h"
6 #include "Visualization/VisualizationZoneWidget.h"
6 #include "Visualization/VisualizationZoneWidget.h"
7
7
8 #include <Variable/Variable.h>
8 #include <Variable/Variable.h>
9
9
10 #include <QMenu>
10 #include <QMenu>
11 #include <QStack>
11 #include <QStack>
12
12
13 Q_LOGGING_CATEGORY(LOG_GenerateVariableMenuOperation, "GenerateVariableMenuOperation")
13 Q_LOGGING_CATEGORY(LOG_GenerateVariableMenuOperation, "GenerateVariableMenuOperation")
14
14
15 struct GenerateVariableMenuOperation::GenerateVariableMenuOperationPrivate {
15 struct GenerateVariableMenuOperation::GenerateVariableMenuOperationPrivate {
16 explicit GenerateVariableMenuOperationPrivate(QMenu *menu, std::shared_ptr<Variable> variable)
16 explicit GenerateVariableMenuOperationPrivate(QMenu *menu, std::shared_ptr<Variable> variable)
17 : m_Variable{variable}, m_PlotMenuBuilder{menu}, m_UnplotMenuBuilder{menu}
17 : m_Variable{variable}, m_PlotMenuBuilder{menu}, m_UnplotMenuBuilder{menu}
18 {
18 {
19 }
19 }
20
20
21 void visitRootEnter()
21 void visitRootEnter()
22 {
22 {
23 // Creates the root menu
23 // Creates the root menu
24 if (auto plotMenu
24 if (auto plotMenu
25 = m_PlotMenuBuilder.addMenu(QObject::tr("Plot"), QIcon{":/icones/plot.png"})) {
25 = m_PlotMenuBuilder.addMenu(QObject::tr("Plot"), QIcon{":/icones/plot.png"})) {
26 plotMenu->setEnabled(m_Variable && m_Variable->dataSeries() != nullptr);
26 plotMenu->setEnabled(m_Variable && m_Variable->dataSeries() != nullptr);
27 }
27 }
28
28
29 m_UnplotMenuBuilder.addMenu(QObject::tr("Unplot"), QIcon{":/icones/unplot.png"});
29 m_UnplotMenuBuilder.addMenu(QObject::tr("Unplot"), QIcon{":/icones/unplot.png"});
30 }
30 }
31
31
32 void visitRootLeave()
32 void visitRootLeave()
33 {
33 {
34 // Closes the root menu
34 // Closes the root menu
35 m_PlotMenuBuilder.closeMenu();
35 m_PlotMenuBuilder.closeMenu();
36 m_UnplotMenuBuilder.closeMenu();
36 m_UnplotMenuBuilder.closeMenu();
37 }
37 }
38
38
39 void visitNodeEnter(const IVisualizationWidget &container)
39 void visitNodeEnter(const IVisualizationWidget &container)
40 {
40 {
41 // Opens a new menu associated to the node
41 // Opens a new menu associated to the node
42 m_PlotMenuBuilder.addMenu(container.name());
42 m_PlotMenuBuilder.addMenu(container.name());
43 m_UnplotMenuBuilder.addMenu(container.name());
43 m_UnplotMenuBuilder.addMenu(container.name());
44 }
44 }
45
45
46 template <typename ActionFun>
46 template <typename ActionFun>
47 void visitNodeLeavePlot(const IVisualizationWidget &container, const QString &actionName,
47 void visitNodeLeavePlot(const IVisualizationWidget &container, const QString &actionName,
48 ActionFun actionFunction)
48 ActionFun actionFunction)
49 {
49 {
50 if (m_Variable && container.canDrop(*m_Variable)) {
50 if (m_Variable && container.canDrop(*m_Variable)) {
51 m_PlotMenuBuilder.addSeparator();
51 m_PlotMenuBuilder.addSeparator();
52 m_PlotMenuBuilder.addAction(actionName, actionFunction);
52 m_PlotMenuBuilder.addAction(actionName, actionFunction);
53 }
53 }
54
54
55 // Closes the menu associated to the node
55 // Closes the menu associated to the node
56 m_PlotMenuBuilder.closeMenu();
56 m_PlotMenuBuilder.closeMenu();
57 }
57 }
58
58
59 void visitNodeLeaveUnplot()
59 void visitNodeLeaveUnplot()
60 {
60 {
61 // Closes the menu associated to the node
61 // Closes the menu associated to the node
62 m_UnplotMenuBuilder.closeMenu();
62 m_UnplotMenuBuilder.closeMenu();
63 }
63 }
64
64
65 template <typename ActionFun>
65 template <typename ActionFun>
66 void visitLeafPlot(const IVisualizationWidget &container, const QString &actionName,
66 void visitLeafPlot(const IVisualizationWidget &container, const QString &actionName,
67 ActionFun actionFunction)
67 ActionFun actionFunction)
68 {
68 {
69 if (m_Variable && container.canDrop(*m_Variable)) {
69 if (m_Variable && container.canDrop(*m_Variable)) {
70 m_PlotMenuBuilder.addAction(actionName, actionFunction);
70 m_PlotMenuBuilder.addAction(actionName, actionFunction);
71 }
71 }
72 }
72 }
73
73
74 template <typename ActionFun>
74 template <typename ActionFun>
75 void visitLeafUnplot(const IVisualizationWidget &container, const QString &actionName,
75 void visitLeafUnplot(const IVisualizationWidget &container, const QString &actionName,
76 ActionFun actionFunction)
76 ActionFun actionFunction)
77 {
77 {
78 if (m_Variable && container.contains(*m_Variable)) {
78 if (m_Variable && container.contains(*m_Variable)) {
79 m_UnplotMenuBuilder.addAction(actionName, actionFunction);
79 m_UnplotMenuBuilder.addAction(actionName, actionFunction);
80 }
80 }
81 }
81 }
82
82
83 std::shared_ptr<Variable> m_Variable;
83 std::shared_ptr<Variable> m_Variable;
84 MenuBuilder m_PlotMenuBuilder; ///< Builder for the 'Plot' menu
84 MenuBuilder m_PlotMenuBuilder; ///< Builder for the 'Plot' menu
85 MenuBuilder m_UnplotMenuBuilder; ///< Builder for the 'Unplot' menu
85 MenuBuilder m_UnplotMenuBuilder; ///< Builder for the 'Unplot' menu
86 };
86 };
87
87
88 GenerateVariableMenuOperation::GenerateVariableMenuOperation(QMenu *menu,
88 GenerateVariableMenuOperation::GenerateVariableMenuOperation(QMenu *menu,
89 std::shared_ptr<Variable> variable)
89 std::shared_ptr<Variable> variable)
90 : impl{spimpl::make_unique_impl<GenerateVariableMenuOperationPrivate>(menu, variable)}
90 : impl{spimpl::make_unique_impl<GenerateVariableMenuOperationPrivate>(menu, variable)}
91 {
91 {
92 }
92 }
93
93
94 void GenerateVariableMenuOperation::visitEnter(VisualizationWidget *widget)
94 void GenerateVariableMenuOperation::visitEnter(VisualizationWidget *widget)
95 {
95 {
96 // VisualizationWidget is not intended to accommodate a variable
96 // VisualizationWidget is not intended to accommodate a variable
97 Q_UNUSED(widget)
97 Q_UNUSED(widget)
98
98
99 // 'Plot' and 'Unplot' menus
99 // 'Plot' and 'Unplot' menus
100 impl->visitRootEnter();
100 impl->visitRootEnter();
101 }
101 }
102
102
103 void GenerateVariableMenuOperation::visitLeave(VisualizationWidget *widget)
103 void GenerateVariableMenuOperation::visitLeave(VisualizationWidget *widget)
104 {
104 {
105 // VisualizationWidget is not intended to accommodate a variable
105 // VisualizationWidget is not intended to accommodate a variable
106 Q_UNUSED(widget)
106 Q_UNUSED(widget)
107
107
108 // 'Plot' and 'Unplot' menus
108 // 'Plot' and 'Unplot' menus
109 impl->visitRootLeave();
109 impl->visitRootLeave();
110 }
110 }
111
111
112 void GenerateVariableMenuOperation::visitEnter(VisualizationTabWidget *tabWidget)
112 void GenerateVariableMenuOperation::visitEnter(VisualizationTabWidget *tabWidget)
113 {
113 {
114 if (tabWidget) {
114 if (tabWidget) {
115 // 'Plot' and 'Unplot' menus
115 // 'Plot' and 'Unplot' menus
116 impl->visitNodeEnter(*tabWidget);
116 impl->visitNodeEnter(*tabWidget);
117 }
117 }
118 else {
118 else {
119 qCCritical(LOG_GenerateVariableMenuOperation(),
119 qCCritical(LOG_GenerateVariableMenuOperation(),
120 "Can't visit enter VisualizationTabWidget : the widget is null");
120 "Can't visit enter VisualizationTabWidget : the widget is null");
121 }
121 }
122 }
122 }
123
123
124 void GenerateVariableMenuOperation::visitLeave(VisualizationTabWidget *tabWidget)
124 void GenerateVariableMenuOperation::visitLeave(VisualizationTabWidget *tabWidget)
125 {
125 {
126 if (tabWidget) {
126 if (tabWidget) {
127 // 'Plot' menu
127 // 'Plot' menu
128 impl->visitNodeLeavePlot(*tabWidget, QObject::tr("Open in a new zone"),
128 impl->visitNodeLeavePlot(*tabWidget, QObject::tr("Open in a new zone"),
129 [ varW = std::weak_ptr<Variable>{impl->m_Variable}, tabWidget ]() {
129 [ varW = std::weak_ptr<Variable>{impl->m_Variable}, tabWidget ]() {
130 if (auto var = varW.lock()) {
130 if (auto var = varW.lock()) {
131 tabWidget->createZone(var);
131 tabWidget->createZone(var);
132 }
132 }
133 });
133 });
134
134
135 // 'Unplot' menu
135 // 'Unplot' menu
136 impl->visitNodeLeaveUnplot();
136 impl->visitNodeLeaveUnplot();
137 }
137 }
138 else {
138 else {
139 qCCritical(LOG_GenerateVariableMenuOperation(),
139 qCCritical(LOG_GenerateVariableMenuOperation(),
140 "Can't visit leave VisualizationTabWidget : the widget is null");
140 "Can't visit leave VisualizationTabWidget : the widget is null");
141 }
141 }
142 }
142 }
143
143
144 void GenerateVariableMenuOperation::visitEnter(VisualizationZoneWidget *zoneWidget)
144 void GenerateVariableMenuOperation::visitEnter(VisualizationZoneWidget *zoneWidget)
145 {
145 {
146 if (zoneWidget) {
146 if (zoneWidget) {
147 // 'Plot' and 'Unplot' menus
147 // 'Plot' and 'Unplot' menus
148 impl->visitNodeEnter(*zoneWidget);
148 impl->visitNodeEnter(*zoneWidget);
149 }
149 }
150 else {
150 else {
151 qCCritical(LOG_GenerateVariableMenuOperation(),
151 qCCritical(LOG_GenerateVariableMenuOperation(),
152 "Can't visit enter VisualizationZoneWidget : the widget is null");
152 "Can't visit enter VisualizationZoneWidget : the widget is null");
153 }
153 }
154 }
154 }
155
155
156 void GenerateVariableMenuOperation::visitLeave(VisualizationZoneWidget *zoneWidget)
156 void GenerateVariableMenuOperation::visitLeave(VisualizationZoneWidget *zoneWidget)
157 {
157 {
158 qCCritical(LOG_GenerateVariableMenuOperation(), "Open in a new graph DETECTED !!");
158 if (zoneWidget) {
159 if (zoneWidget) {
159 // 'Plot' menu
160 // 'Plot' menu
160 impl->visitNodeLeavePlot(
161 impl->visitNodeLeavePlot(
161 *zoneWidget, QObject::tr("Open in a new graph"),
162 *zoneWidget, QObject::tr("Open in a new graph"),
162 [ varW = std::weak_ptr<Variable>{impl->m_Variable}, zoneWidget ]() {
163 [ varW = std::weak_ptr<Variable>{impl->m_Variable}, zoneWidget ]() {
163 if (auto var = varW.lock()) {
164 if (auto var = varW.lock()) {
164 zoneWidget->createGraph(var);
165 zoneWidget->createGraph(var);
165 }
166 }
166 });
167 });
167
168
168 // 'Unplot' menu
169 // 'Unplot' menu
169 impl->visitNodeLeaveUnplot();
170 impl->visitNodeLeaveUnplot();
170 }
171 }
171 else {
172 else {
172 qCCritical(LOG_GenerateVariableMenuOperation(),
173 qCCritical(LOG_GenerateVariableMenuOperation(),
173 "Can't visit leave VisualizationZoneWidget : the widget is null");
174 "Can't visit leave VisualizationZoneWidget : the widget is null");
174 }
175 }
175 }
176 }
176
177
177 void GenerateVariableMenuOperation::visit(VisualizationGraphWidget *graphWidget)
178 void GenerateVariableMenuOperation::visit(VisualizationGraphWidget *graphWidget)
178 {
179 {
179 if (graphWidget) {
180 if (graphWidget) {
180 // 'Plot' menu
181 // 'Plot' menu
181 impl->visitLeafPlot(*graphWidget, QObject::tr("Open in %1").arg(graphWidget->name()),
182 impl->visitLeafPlot(*graphWidget, QObject::tr("Open in %1").arg(graphWidget->name()),
182 [ varW = std::weak_ptr<Variable>{impl->m_Variable}, graphWidget ]() {
183 [ varW = std::weak_ptr<Variable>{impl->m_Variable}, graphWidget ]() {
183 if (auto var = varW.lock()) {
184 if (auto var = varW.lock()) {
184 graphWidget->addVariableUsingGraph(var);
185 graphWidget->addVariable(var, graphWidget->graphRange());
185 }
186 }
186 });
187 });
187
188
188 // 'Unplot' menu
189 // 'Unplot' menu
189 impl->visitLeafUnplot(*graphWidget, QObject::tr("Remove from %1").arg(graphWidget->name()),
190 impl->visitLeafUnplot(*graphWidget, QObject::tr("Remove from %1").arg(graphWidget->name()),
190 [ varW = std::weak_ptr<Variable>{impl->m_Variable}, graphWidget ]() {
191 [ varW = std::weak_ptr<Variable>{impl->m_Variable}, graphWidget ]() {
191 if (auto var = varW.lock()) {
192 if (auto var = varW.lock()) {
192 graphWidget->removeVariable(var);
193 graphWidget->removeVariable(var);
193 }
194 }
194 });
195 });
195 }
196 }
196 else {
197 else {
197 qCCritical(LOG_GenerateVariableMenuOperation(),
198 qCCritical(LOG_GenerateVariableMenuOperation(),
198 "Can't visit VisualizationGraphWidget : the widget is null");
199 "Can't visit VisualizationGraphWidget : the widget is null");
199 }
200 }
200 }
201 }
Show file before | Show file after | Hide comments
@@ -1,103 +1,103
1 #include "CosinusProvider.h"
1 #include "CosinusProvider.h"
2
2
3 #include <Data/DataProviderParameters.h>
3 #include <Data/DataProviderParameters.h>
4 #include <Data/ScalarSeries.h>
4 #include <Data/ScalarSeries.h>
5
5
6 #include <cmath>
6 #include <cmath>
7
7
8 #include <QFuture>
8 #include <QFuture>
9 #include <QThread>
9 #include <QThread>
10 #include <QtConcurrent/QtConcurrent>
10 #include <QtConcurrent/QtConcurrent>
11
11
12 Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
12 Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
13
13
14 std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
14 std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
15 const SqpRange &dataRangeRequested)
15 const SqpRange &dataRangeRequested)
16 {
16 {
17 // TODO: Add Mutex
17 // TODO: Add Mutex
18 auto dataIndex = 0;
18 auto dataIndex = 0;
19
19
20 // Gets the timerange from the parameters
20 // Gets the timerange from the parameters
21 double freq = 100.0;
21 double freq = 100.0;
22 double start = std::ceil(dataRangeRequested.m_TStart * freq); // 100 htz
22 double start = std::ceil(dataRangeRequested.m_TStart * freq); // 100 htz
23 double end = std::floor(dataRangeRequested.m_TEnd * freq); // 100 htz
23 double end = std::floor(dataRangeRequested.m_TEnd * freq); // 100 htz
24
24
25 // We assure that timerange is valid
25 // We assure that timerange is valid
26 if (end < start) {
26 if (end < start) {
27 std::swap(start, end);
27 std::swap(start, end);
28 }
28 }
29
29
30 // Generates scalar series containing cosinus values (one value per second)
30 // Generates scalar series containing cosinus values (one value per second)
31 auto dataCount = end - start;
31 auto dataCount = end - start;
32
32
33 auto xAxisData = QVector<double>{};
33 auto xAxisData = QVector<double>{};
34 xAxisData.resize(dataCount);
34 xAxisData.resize(dataCount);
35
35
36 auto valuesData = QVector<double>{};
36 auto valuesData = QVector<double>{};
37 valuesData.resize(dataCount);
37 valuesData.resize(dataCount);
38
38
39 int progress = 0;
39 int progress = 0;
40 auto progressEnd = dataCount;
40 auto progressEnd = dataCount;
41 for (auto time = start; time < end; ++time, ++dataIndex) {
41 for (auto time = start; time < end; ++time, ++dataIndex) {
42 auto it = m_VariableToEnableProvider.find(acqIdentifier);
42 auto it = m_VariableToEnableProvider.find(acqIdentifier);
43 if (it != m_VariableToEnableProvider.end() && it.value()) {
43 if (it != m_VariableToEnableProvider.end() && it.value()) {
44 const auto timeOnFreq = time / freq;
44 const auto timeOnFreq = time / freq;
45
45
46 xAxisData.replace(dataIndex, timeOnFreq);
46 xAxisData.replace(dataIndex, timeOnFreq);
47 valuesData.replace(dataIndex, std::cos(timeOnFreq));
47 valuesData.replace(dataIndex, std::cos(timeOnFreq));
48
48
49 // progression
49 // progression
50 int currentProgress = (time - start) * 100.0 / progressEnd;
50 int currentProgress = (time - start) * 100.0 / progressEnd;
51 if (currentProgress != progress) {
51 if (currentProgress != progress) {
52 progress = currentProgress;
52 progress = currentProgress;
53
53
54 emit dataProvidedProgress(acqIdentifier, progress);
54 emit dataProvidedProgress(acqIdentifier, progress);
55 }
55 }
56 }
56 }
57 else {
57 else {
58 if (!it.value()) {
58 if (!it.value()) {
59 qCDebug(LOG_CosinusProvider())
59 qCDebug(LOG_CosinusProvider())
60 << "CosinusProvider::retrieveData: ARRET De l'acquisition detectΓ©"
60 << "CosinusProvider::retrieveData: ARRET De l'acquisition detectΓ©"
61 << end - time;
61 << end - time;
62 }
62 }
63 }
63 }
64 }
64 }
65 emit dataProvidedProgress(acqIdentifier, 0.0);
65 emit dataProvidedProgress(acqIdentifier, 0.0);
66
66
67 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
67 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
68 Unit{QStringLiteral("t"), true}, Unit{});
68 Unit{QStringLiteral("t"), true}, Unit{});
69 }
69 }
70
70
71 void CosinusProvider::requestDataLoading(QUuid acqIdentifier,
71 void CosinusProvider::requestDataLoading(QUuid acqIdentifier,
72 const DataProviderParameters &parameters)
72 const DataProviderParameters &parameters)
73 {
73 {
74 // TODO: Add Mutex
74 // TODO: Add Mutex
75 m_VariableToEnableProvider[acqIdentifier] = true;
75 m_VariableToEnableProvider[acqIdentifier] = true;
76 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataLoading"
76 qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::requestDataLoading"
77 << QThread::currentThread()->objectName();
77 << QThread::currentThread()->objectName();
78 // NOTE: Try to use multithread if possible
78 // NOTE: Try to use multithread if possible
79 const auto times = parameters.m_Times;
79 const auto times = parameters.m_Times;
80
80
81 for (const auto &dateTime : qAsConst(times)) {
81 for (const auto &dateTime : qAsConst(times)) {
82 if (m_VariableToEnableProvider[acqIdentifier]) {
82 if (m_VariableToEnableProvider[acqIdentifier]) {
83 auto scalarSeries = this->retrieveData(acqIdentifier, dateTime);
83 auto scalarSeries = this->retrieveData(acqIdentifier, dateTime);
84 qCCritical(LOG_CosinusProvider()) << "CosinusProvider::dataProvided";
84 qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::dataProvided";
85 emit dataProvided(acqIdentifier, scalarSeries, dateTime);
85 emit dataProvided(acqIdentifier, scalarSeries, dateTime);
86 }
86 }
87 }
87 }
88 }
88 }
89
89
90 void CosinusProvider::requestDataAborting(QUuid acqIdentifier)
90 void CosinusProvider::requestDataAborting(QUuid acqIdentifier)
91 {
91 {
92 // TODO: Add Mutex
92 // TODO: Add Mutex
93 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << acqIdentifier
93 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << acqIdentifier
94 << QThread::currentThread()->objectName();
94 << QThread::currentThread()->objectName();
95 auto it = m_VariableToEnableProvider.find(acqIdentifier);
95 auto it = m_VariableToEnableProvider.find(acqIdentifier);
96 if (it != m_VariableToEnableProvider.end()) {
96 if (it != m_VariableToEnableProvider.end()) {
97 it.value() = false;
97 it.value() = false;
98 }
98 }
99 else {
99 else {
100 qCWarning(LOG_CosinusProvider())
100 qCWarning(LOG_CosinusProvider())
101 << tr("Aborting progression of inexistant identifier detected !!!");
101 << tr("Aborting progression of inexistant identifier detected !!!");
102 }
102 }
103 }
103 }
General Comments 1
Under Review
perrinel
author
Comment #1895
Edit
Delete
|

Auto status change to "Under Review"

You need to be logged in to leave comments. Login now