##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SciQLop-fork
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Merge pull request 229 from SCIQLOP-Initialisation develop...
perrinel -
r588:aa5771ec396c merge
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,19
1 #ifndef SCIQLOP_COLORUTILS_H
2 #define SCIQLOP_COLORUTILS_H
3
4 #include <vector>
5
6 class QColor;
7
8 /**
9 * Utility class with methods for colors
10 */
11 struct ColorUtils {
12 /// Generates a color scale from min / max values and a number of colors.
13 /// The algorithm uses the HSV color model to generate color variations (see
14 /// http://doc.qt.io/qt-4.8/qcolor.html#the-hsv-color-model)
15 static std::vector<QColor> colors(const QColor &minColor, const QColor &maxColor,
16 int nbColors) noexcept;
17 };
18
19 #endif // SCIQLOP_COLORUTILS_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,10
1 #ifndef SCIQLOP_VISUALIZATIONDEFS_H
2 #define SCIQLOP_VISUALIZATIONDEFS_H
3
4 #include <map>
5
6 class QCPAbstractPlottable;
7
8 using PlottablesMap = std::map<int, QCPAbstractPlottable *>;
9
10 #endif // SCIQLOP_VISUALIZATIONDEFS_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,29
1 #include "Common/ColorUtils.h"
2
3 #include <QtGui/QColor>
4
5 std::vector<QColor> ColorUtils::colors(const QColor &minColor, const QColor &maxColor,
6 int nbColors) noexcept
7 {
8 auto result = std::vector<QColor>{};
9
10 if (nbColors == 1) {
11 result.push_back(minColor);
12 }
13 else if (nbColors > 0) {
14 const auto nbSteps = static_cast<double>(nbColors - 1);
15
16 const auto colorHStep = (maxColor.hue() - minColor.hue()) / nbSteps;
17 const auto colorSStep = (maxColor.saturation() - minColor.saturation()) / nbSteps;
18 const auto colorVStep = (maxColor.value() - minColor.value()) / nbSteps;
19 const auto colorAStep = (maxColor.alpha() - minColor.alpha()) / nbSteps;
20
21 for (auto i = 0; i < nbColors; ++i) {
22 result.push_back(QColor::fromHsv(
23 minColor.hue() + i * colorHStep, minColor.saturation() + i * colorSStep,
24 minColor.value() + i * colorVStep, minColor.alpha() + i * colorAStep));
25 }
26 }
27
28 return result;
29 }
Show file before | Show file after | Hide comments
@@ -218,6 +218,8 public:
218 }
218 }
219 }
219 }
220
220
221 int componentCount() const noexcept { return m_Data.size(); }
222
221 /**
223 /**
222 * @return the data of a component
224 * @return the data of a component
223 * @param componentIndex the index of the component to retrieve the data
225 * @param componentIndex the index of the component to retrieve the data
Show file before | Show file after | Hide comments
@@ -208,11 +208,11 public:
208
208
209 auto lowerIt
209 auto lowerIt
210 = std::lower_bound(begin, end, min, [](const auto &itValue, const auto &value) {
210 = std::lower_bound(begin, end, min, [](const auto &itValue, const auto &value) {
211 return itValue.x() == value;
211 return itValue.x() < value;
212 });
212 });
213 auto upperIt
213 auto upperIt
214 = std::upper_bound(begin, end, max, [](const auto &value, const auto &itValue) {
214 = std::upper_bound(begin, end, max, [](const auto &value, const auto &itValue) {
215 return itValue.x() == value;
215 return value < itValue.x();
216 });
216 });
217
217
218 return std::make_pair(lowerIt, upperIt);
218 return std::make_pair(lowerIt, upperIt);
Show file before | Show file after | Hide comments
@@ -22,6 +22,13 private slots:
22
22
23 /// Tests merge of two data series
23 /// Tests merge of two data series
24 void testMerge();
24 void testMerge();
25
26 /// Input test data
27 /// @sa testSubdata()
28 void testSubdata_data();
29
30 /// Tests get subdata of two data series
31 void testSubdata();
25 };
32 };
26
33
27 void TestDataSeries::testCtor_data()
34 void TestDataSeries::testCtor_data()
@@ -160,5 +167,66 void TestDataSeries::testMerge()
160 seriesValuesData.cbegin()));
167 seriesValuesData.cbegin()));
161 }
168 }
162
169
170 void TestDataSeries::testSubdata_data()
171 {
172 // ////////////// //
173 // Test structure //
174 // ////////////// //
175
176 // Data series to get subdata
177 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
178
179 // Min/max values
180 QTest::addColumn<double>("min");
181 QTest::addColumn<double>("max");
182
183 // Expected values after subdata
184 QTest::addColumn<QVector<double> >("expectedXAxisData");
185 QTest::addColumn<QVector<double> >("expectedValuesData");
186
187 // ////////// //
188 // Test cases //
189 // ////////// //
190
191 QTest::newRow("subData1") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
192 << -1. << 3.2 << QVector<double>{1., 2., 3.}
193 << QVector<double>{100., 200., 300.};
194 QTest::newRow("subData2") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
195 << 1. << 4. << QVector<double>{1., 2., 3., 4.}
196 << QVector<double>{100., 200., 300., 400.};
197 QTest::newRow("subData3") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
198 << 1. << 3.9 << QVector<double>{1., 2., 3.}
199 << QVector<double>{100., 200., 300.};
200 QTest::newRow("subData4") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
201 << 0. << 0.9 << QVector<double>{} << QVector<double>{};
202 QTest::newRow("subData5") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
203 << 0. << 1. << QVector<double>{1.} << QVector<double>{100.};
204 QTest::newRow("subData6") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
205 << 2.1 << 6. << QVector<double>{3., 4., 5.}
206 << QVector<double>{300., 400., 500.};
207 QTest::newRow("subData7") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
208 << 6. << 9. << QVector<double>{} << QVector<double>{};
209 QTest::newRow("subData8") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
210 << 5. << 9. << QVector<double>{5.} << QVector<double>{500.};
211 }
212
213 void TestDataSeries::testSubdata()
214 {
215 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
216 QFETCH(double, min);
217 QFETCH(double, max);
218
219 QFETCH(QVector<double>, expectedXAxisData);
220 QFETCH(QVector<double>, expectedValuesData);
221
222 auto bounds = dataSeries->subData(min, max);
223 QVERIFY(std::equal(bounds.first, bounds.second, expectedXAxisData.cbegin(),
224 expectedXAxisData.cend(),
225 [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
226 QVERIFY(std::equal(
227 bounds.first, bounds.second, expectedValuesData.cbegin(), expectedValuesData.cend(),
228 [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
229 }
230
163 QTEST_MAIN(TestDataSeries)
231 QTEST_MAIN(TestDataSeries)
164 #include "TestDataSeries.moc"
232 #include "TestDataSeries.moc"
Show file before | Show file after | Hide comments
@@ -1,6 +1,8
1 #ifndef SCIQLOP_VISUALIZATIONGRAPHHELPER_H
1 #ifndef SCIQLOP_VISUALIZATIONGRAPHHELPER_H
2 #define SCIQLOP_VISUALIZATIONGRAPHHELPER_H
2 #define SCIQLOP_VISUALIZATIONGRAPHHELPER_H
3
3
4 #include "Visualization/VisualizationDefs.h"
5
4 #include <Data/SqpRange.h>
6 #include <Data/SqpRange.h>
5
7
6 #include <QLoggingCategory>
8 #include <QLoggingCategory>
@@ -28,13 +30,10 struct VisualizationGraphHelper {
28 * components.
30 * components.
29 * @return the list of the components created
31 * @return the list of the components created
30 */
32 */
31 static QVector<QCPAbstractPlottable *> create(std::shared_ptr<Variable> variable,
33 static PlottablesMap create(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept;
32 QCustomPlot &plot) noexcept;
33 static QVector<QCPAbstractPlottable *> createV2(std::shared_ptr<Variable> variable,
34 QCustomPlot &plot) noexcept;
35
34
36 static void updateData(QVector<QCPAbstractPlottable *> plotableVect,
35 static void updateData(PlottablesMap &plottables, std::shared_ptr<IDataSeries> dataSeries,
37 std::shared_ptr<IDataSeries> dataSeries, const SqpRange &dateTime);
36 const SqpRange &dateTime);
38 };
37 };
39
38
40 #endif // SCIQLOP_VISUALIZATIONGRAPHHELPER_H
39 #endif // SCIQLOP_VISUALIZATIONGRAPHHELPER_H
Show file before | Show file after | Hide comments
@@ -1,7 +1,10
1 #include "Visualization/VisualizationGraphHelper.h"
1 #include "Visualization/VisualizationGraphHelper.h"
2 #include "Visualization/qcustomplot.h"
2 #include "Visualization/qcustomplot.h"
3
3
4 #include <Common/ColorUtils.h>
5
4 #include <Data/ScalarSeries.h>
6 #include <Data/ScalarSeries.h>
7 #include <Data/VectorSeries.h>
5
8
6 #include <Variable/Variable.h>
9 #include <Variable/Variable.h>
7
10
@@ -35,161 +38,203 QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
35 }
38 }
36 }
39 }
37
40
38 void updateScalarData(QCPAbstractPlottable *component, std::shared_ptr<ScalarSeries> scalarSeries,
41 /// Sets axes properties according to the properties of a data series
39 const SqpRange &range)
42 template <int Dim>
43 void setAxesProperties(const DataSeries<Dim> &dataSeries, QCustomPlot &plot) noexcept
40 {
44 {
41 qCDebug(LOG_VisualizationGraphHelper()) << "TORM: updateScalarData"
45 /// @todo : for the moment, no control is performed on the axes: the units and the tickers
42 << QThread::currentThread()->objectName();
46 /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
43 if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
47 auto setAxisProperties = [](auto axis, const auto &unit) {
44 scalarSeries->lockRead();
48 // label (unit name)
45 {
49 axis->setLabel(unit.m_Name);
46 auto sqpDataContainer = QSharedPointer<SqpDataContainer>::create();
50
47 qcpGraph->setData(sqpDataContainer);
51 // ticker (depending on the type of unit)
48 auto bounds = scalarSeries->subData(range.m_TStart, range.m_TEnd);
52 axis->setTicker(axisTicker(unit.m_TimeUnit));
49 for (auto it = bounds.first; it != bounds.second; ++it) {
53 };
50 sqpDataContainer->appendGraphData(QCPGraphData(it->x(), it->value()));
54 setAxisProperties(plot.xAxis, dataSeries.xAxisUnit());
51 }
55 setAxisProperties(plot.yAxis, dataSeries.valuesUnit());
52
56 }
53 qCInfo(LOG_VisualizationGraphHelper()) << "TODEBUG: Current points displayed"
54 << sqpDataContainer->size();
55 }
56 scalarSeries->unlock();
57
58
57
59 // Display all data
58 /**
60 component->parentPlot()->replot();
59 * Struct used to create plottables, depending on the type of the data series from which to create them
61 }
60 * @tparam T the data series' type
62 else {
61 * @remarks Default implementation can't create plottables
63 /// @todo DEBUG
62 */
63 template <typename T, typename Enabled = void>
64 struct PlottablesCreator {
65 static PlottablesMap createPlottables(T &, QCustomPlot &)
66 {
67 qCCritical(LOG_DataSeries())
68 << QObject::tr("Can't create plottables: unmanaged data series type");
69 return {};
64 }
70 }
65 }
71 };
66
72
67 QCPAbstractPlottable *createScalarSeriesComponentV2(std::shared_ptr<ScalarSeries> scalarSeries,
73 /**
68 QCustomPlot &plot)
74 * Specialization of PlottablesCreator for scalars and vectors
69 {
75 * @sa ScalarSeries
70 auto component = plot.addGraph();
76 * @sa VectorSeries
77 */
78 template <typename T>
79 struct PlottablesCreator<T,
80 typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
81 or std::is_base_of<VectorSeries, T>::value> > {
82 static PlottablesMap createPlottables(T &dataSeries, QCustomPlot &plot)
83 {
84 PlottablesMap result{};
85
86 // Gets the number of components of the data series
87 auto componentCount = dataSeries.valuesData()->componentCount();
88
89 auto colors = ColorUtils::colors(Qt::blue, Qt::red, componentCount);
90
91 // For each component of the data series, creates a QCPGraph to add to the plot
92 for (auto i = 0; i < componentCount; ++i) {
93 auto graph = plot.addGraph();
94 graph->setPen(QPen{colors.at(i)});
95
96 result.insert({i, graph});
97 }
71
98
72 if (component) {
73 // Axes properties
99 // Axes properties
74 /// @todo : for the moment, no control is performed on the axes: the units and the tickers
100 setAxesProperties(dataSeries, plot);
75 /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
101
76
102 plot.replot();
77 auto setAxisProperties = [](auto axis, const auto &unit) {
103
78 // label (unit name)
104 return result;
79 axis->setLabel(unit.m_Name);
80
81 // ticker (depending on the type of unit)
82 axis->setTicker(axisTicker(unit.m_TimeUnit));
83 };
84 setAxisProperties(plot.xAxis, scalarSeries->xAxisUnit());
85 setAxisProperties(plot.yAxis, scalarSeries->valuesUnit());
86 }
105 }
87 return component;
106 };
88 }
89
107
90 QCPAbstractPlottable *createScalarSeriesComponent(std::shared_ptr<ScalarSeries> scalarSeries,
108 /**
91 QCustomPlot &plot, const SqpRange &dateTime)
109 * Struct used to update plottables, depending on the type of the data series from which to update them
92 {
110 * @tparam T the data series' type
93 auto component = plot.addGraph();
111 * @remarks Default implementation can't update plottables
112 */
113 template <typename T, typename Enabled = void>
114 struct PlottablesUpdater {
115 static void updatePlottables(T &, PlottablesMap &, const SqpRange &, bool)
116 {
117 qCCritical(LOG_DataSeries())
118 << QObject::tr("Can't update plottables: unmanaged data series type");
119 }
120 };
94
121
95 if (component) {
122 /**
96 // // Graph data
123 * Specialization of PlottablesUpdater for scalars and vectors
97 component->setData(scalarSeries->xAxisData()->data(), scalarSeries->valuesData()->data(),
124 * @sa ScalarSeries
98 true);
125 * @sa VectorSeries
126 */
127 template <typename T>
128 struct PlottablesUpdater<T,
129 typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
130 or std::is_base_of<VectorSeries, T>::value> > {
131 static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const SqpRange &range,
132 bool rescaleAxes)
133 {
134 dataSeries.lockRead();
135
136 // For each plottable to update, resets its data
137 std::map<int, QSharedPointer<SqpDataContainer> > dataContainers{};
138 for (const auto &plottable : plottables) {
139 if (auto graph = dynamic_cast<QCPGraph *>(plottable.second)) {
140 auto dataContainer = QSharedPointer<SqpDataContainer>::create();
141 graph->setData(dataContainer);
142
143 dataContainers.insert({plottable.first, dataContainer});
144 }
145 }
99
146
100 updateScalarData(component, scalarSeries, dateTime);
147 // - Gets the data of the series included in the current range
148 // - Updates each plottable by adding, for each data item, a point that takes x-axis data and value data. The correct value is retrieved according to the index of the component
149 auto subDataIts = dataSeries.subData(range.m_TStart, range.m_TEnd);
150 for (auto it = subDataIts.first; it != subDataIts.second; ++it) {
151 for (const auto &dataContainer : dataContainers) {
152 auto componentIndex = dataContainer.first;
153 dataContainer.second->appendGraphData(
154 QCPGraphData(it->x(), it->value(componentIndex)));
155 }
156 }
101
157
102 // Axes properties
158 dataSeries.unlock();
103 /// @todo : for the moment, no control is performed on the axes: the units and the tickers
104 /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
105
159
106 auto setAxisProperties = [](auto axis, const auto &unit) {
160 if (!plottables.empty()) {
107 // label (unit name)
161 auto plot = plottables.begin()->second->parentPlot();
108 axis->setLabel(unit.m_Name);
109
162
110 // ticker (depending on the type of unit)
163 if (rescaleAxes) {
111 axis->setTicker(axisTicker(unit.m_TimeUnit));
164 plot->rescaleAxes();
112 };
165 }
113 setAxisProperties(plot.xAxis, scalarSeries->xAxisUnit());
114 setAxisProperties(plot.yAxis, scalarSeries->valuesUnit());
115
166
116 // Display all data
167 plot->replot();
117 component->rescaleAxes();
168 }
118 plot.replot();
119 }
169 }
120 else {
170 };
121 qCDebug(LOG_VisualizationGraphHelper())
171
122 << QObject::tr("Can't create graph for the scalar series");
172 /**
173 * Helper used to create/update plottables
174 */
175 struct IPlottablesHelper {
176 virtual ~IPlottablesHelper() noexcept = default;
177 virtual PlottablesMap create(QCustomPlot &plot) const = 0;
178 virtual void update(PlottablesMap &plottables, const SqpRange &range,
179 bool rescaleAxes = false) const = 0;
180 };
181
182 /**
183 * Default implementation of IPlottablesHelper, which takes data series to create/update plottables
184 * @tparam T the data series' type
185 */
186 template <typename T>
187 struct PlottablesHelper : public IPlottablesHelper {
188 explicit PlottablesHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
189
190 PlottablesMap create(QCustomPlot &plot) const override
191 {
192 return PlottablesCreator<T>::createPlottables(m_DataSeries, plot);
123 }
193 }
124
194
125 return component;
195 void update(PlottablesMap &plottables, const SqpRange &range, bool rescaleAxes) const override
126 }
196 {
197 PlottablesUpdater<T>::updatePlottables(m_DataSeries, plottables, range, rescaleAxes);
198 }
127
199
128 } // namespace
200 T &m_DataSeries;
201 };
129
202
130 QVector<QCPAbstractPlottable *>
203 /// Creates IPlottablesHelper according to a data series
131 VisualizationGraphHelper::createV2(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept
204 std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<IDataSeries> dataSeries) noexcept
132 {
205 {
133 auto result = QVector<QCPAbstractPlottable *>{};
206 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
134
207 return std::make_unique<PlottablesHelper<ScalarSeries> >(*scalarSeries);
135 if (variable) {
208 }
136 // Gets the data series of the variable to call the creation of the right components
209 else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
137 // according to its type
210 return std::make_unique<PlottablesHelper<VectorSeries> >(*vectorSeries);
138 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(variable->dataSeries())) {
139 result.append(createScalarSeriesComponentV2(scalarSeries, plot));
140 }
141 else {
142 qCDebug(LOG_VisualizationGraphHelper())
143 << QObject::tr("Can't create graph plottables : unmanaged data series type");
144 }
145 }
211 }
146 else {
212 else {
147 qCDebug(LOG_VisualizationGraphHelper())
213 return std::make_unique<PlottablesHelper<IDataSeries> >(*dataSeries);
148 << QObject::tr("Can't create graph plottables : the variable is null");
149 }
214 }
150
151 return result;
152 }
215 }
153
216
154 QVector<QCPAbstractPlottable *> VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
217 } // namespace
155 QCustomPlot &plot) noexcept
156 {
157 auto result = QVector<QCPAbstractPlottable *>{};
158
218
219 PlottablesMap VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
220 QCustomPlot &plot) noexcept
221 {
159 if (variable) {
222 if (variable) {
160 // Gets the data series of the variable to call the creation of the right components
223 auto helper = createHelper(variable->dataSeries());
161 // according to its type
224 auto plottables = helper->create(plot);
162 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(variable->dataSeries())) {
225 return plottables;
163 result.append(createScalarSeriesComponent(scalarSeries, plot, variable->range()));
164 }
165 else {
166 qCDebug(LOG_VisualizationGraphHelper())
167 << QObject::tr("Can't create graph plottables : unmanaged data series type");
168 }
169 }
226 }
170 else {
227 else {
171 qCDebug(LOG_VisualizationGraphHelper())
228 qCDebug(LOG_VisualizationGraphHelper())
172 << QObject::tr("Can't create graph plottables : the variable is null");
229 << QObject::tr("Can't create graph plottables : the variable is null");
230 return PlottablesMap{};
173 }
231 }
174
175 return result;
176 }
232 }
177
233
178 void VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *> plotableVect,
234 void VisualizationGraphHelper::updateData(PlottablesMap &plottables,
179 std::shared_ptr<IDataSeries> dataSeries,
235 std::shared_ptr<IDataSeries> dataSeries,
180 const SqpRange &dateTime)
236 const SqpRange &dateTime)
181 {
237 {
182 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
238 auto helper = createHelper(dataSeries);
183 if (plotableVect.size() == 1) {
239 helper->update(plottables, dateTime);
184 updateScalarData(plotableVect.at(0), scalarSeries, dateTime);
185 }
186 else {
187 qCCritical(LOG_VisualizationGraphHelper()) << QObject::tr(
188 "Can't update Data of a scalarSeries because there is not only one component "
189 "associated");
190 }
191 }
192 else {
193 /// @todo DEBUG
194 }
195 }
240 }
Show file before | Show file after | Hide comments
@@ -1,5 +1,6
1 #include "Visualization/VisualizationGraphWidget.h"
1 #include "Visualization/VisualizationGraphWidget.h"
2 #include "Visualization/IVisualizationWidgetVisitor.h"
2 #include "Visualization/IVisualizationWidgetVisitor.h"
3 #include "Visualization/VisualizationDefs.h"
3 #include "Visualization/VisualizationGraphHelper.h"
4 #include "Visualization/VisualizationGraphHelper.h"
4 #include "Visualization/VisualizationGraphRenderingDelegate.h"
5 #include "Visualization/VisualizationGraphRenderingDelegate.h"
5 #include "ui_VisualizationGraphWidget.h"
6 #include "ui_VisualizationGraphWidget.h"
@@ -33,7 +34,7 struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
33 }
34 }
34
35
35 // 1 variable -> n qcpplot
36 // 1 variable -> n qcpplot
36 std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
37 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
37 bool m_DoAcquisition;
38 bool m_DoAcquisition;
38 bool m_IsCalibration;
39 bool m_IsCalibration;
39 QCPItemTracer *m_TextTracer;
40 QCPItemTracer *m_TextTracer;
@@ -99,11 +100,8 void VisualizationGraphWidget::enableAcquisition(bool enable)
99 void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
100 void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
100 {
101 {
101 // Uses delegate to create the qcpplot components according to the variable
102 // Uses delegate to create the qcpplot components according to the variable
102 auto createdPlottables = VisualizationGraphHelper::createV2(variable, *ui->widget);
103 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
103
104 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
104 for (auto createdPlottable : qAsConst(createdPlottables)) {
105 impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
106 }
107
105
108 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
106 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
109
107
@@ -124,10 +122,17 void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable
124 // Each component associated to the variable :
122 // Each component associated to the variable :
125 // - is removed from qcpplot (which deletes it)
123 // - is removed from qcpplot (which deletes it)
126 // - is no longer referenced in the map
124 // - is no longer referenced in the map
127 auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
125 auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);
128 for (auto it = componentsIt.first; it != componentsIt.second;) {
126 if (variableIt != impl->m_VariableToPlotMultiMap.cend()) {
129 ui->widget->removePlottable(it->second);
127 auto &plottablesMap = variableIt->second;
130 it = impl->m_VariableToPlotMultiMap.erase(it);
128
129 for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
130 plottableIt != plottableEnd;) {
131 ui->widget->removePlottable(plottableIt->second);
132 plottableIt = plottablesMap.erase(plottableIt);
133 }
134
135 impl->m_VariableToPlotMultiMap.erase(variableIt);
131 }
136 }
132
137
133 // Updates graph
138 // Updates graph
@@ -282,29 +287,18 void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
282
287
283 void VisualizationGraphWidget::onDataCacheVariableUpdated()
288 void VisualizationGraphWidget::onDataCacheVariableUpdated()
284 {
289 {
285 // NOTE:
286 // We don't want to call the method for each component of a variable unitarily, but for
287 // all
288 // its components at once (eg its three components in the case of a vector).
289
290 // The unordered_multimap does not do this easily, so the question is whether to:
291 // - use an ordered_multimap and the algos of std to group the values by key
292 // - use a map (unique keys) and store as values directly the list of components
293
294 auto graphRange = ui->widget->xAxis->range();
290 auto graphRange = ui->widget->xAxis->range();
295 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
291 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
296
292
297 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
293 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
298 it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
294 auto variable = variableEntry.first;
299 auto variable = it->first;
300 qCDebug(LOG_VisualizationGraphWidget())
295 qCDebug(LOG_VisualizationGraphWidget())
301 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
296 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
302 qCDebug(LOG_VisualizationGraphWidget())
297 qCDebug(LOG_VisualizationGraphWidget())
303 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
298 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
304 if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
299 if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
305
300 VisualizationGraphHelper::updateData(variableEntry.second, variable->dataSeries(),
306 VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
301 variable->range());
307 variable->dataSeries(), variable->range());
308 }
302 }
309 }
303 }
310 }
304 }
@@ -312,9 +306,8 void VisualizationGraphWidget::onDataCacheVariableUpdated()
312 void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
306 void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
313 const SqpRange &range)
307 const SqpRange &range)
314 {
308 {
315 auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
309 auto it = impl->m_VariableToPlotMultiMap.find(variable);
316 for (auto it = componentsIt.first; it != componentsIt.second;) {
310 if (it != impl->m_VariableToPlotMultiMap.end()) {
317 VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
311 VisualizationGraphHelper::updateData(it->second, variable->dataSeries(), range);
318 variable->dataSeries(), range);
319 }
312 }
320 }
313 }
General Comments 0
You need to be logged in to leave comments. Login now