@@ -44,9 +44,9 public: | |||
|
44 | 44 | * @remarks this method is only available for a unidimensional ArrayData |
|
45 | 45 | */ |
|
46 | 46 | template <int D = Dim, typename = std::enable_if_t<D == 1> > |
|
47 | QVector<double> data() const noexcept | |
|
47 | const QVector<double> &data() const noexcept | |
|
48 | 48 | { |
|
49 |
return m_Data |
|
|
49 | return m_Data[0]; | |
|
50 | 50 | } |
|
51 | 51 | |
|
52 | 52 | /** |
@@ -61,10 +61,10 public: | |||
|
61 | 61 | |
|
62 | 62 | // TODO Comment |
|
63 | 63 | template <int D = Dim, typename = std::enable_if_t<D == 1> > |
|
64 |
void merge(ArrayData<1> |
|
|
64 | void merge(const ArrayData<1> &arrayData) | |
|
65 | 65 | { |
|
66 | 66 | if (!m_Data.empty()) { |
|
67 |
m_Data[0] += arrayData |
|
|
67 | m_Data[0] += arrayData.data(); | |
|
68 | 68 | } |
|
69 | 69 | } |
|
70 | 70 |
@@ -40,8 +40,8 public: | |||
|
40 | 40 | void merge(IDataSeries *dataSeries) override |
|
41 | 41 | { |
|
42 | 42 | if (auto dimDataSeries = dynamic_cast<DataSeries<Dim> *>(dataSeries)) { |
|
43 |
m_XAxisData->merge(dimDataSeries->xAxisData() |
|
|
44 |
m_ValuesData->merge(dimDataSeries->valuesData() |
|
|
43 | m_XAxisData->merge(*dimDataSeries->xAxisData()); | |
|
44 | m_ValuesData->merge(*dimDataSeries->valuesData()); | |
|
45 | 45 | } |
|
46 | 46 | else { |
|
47 | 47 | qCWarning(LOG_DataSeries()) |
@@ -2,6 +2,10 | |||
|
2 | 2 | #define SCIQLOP_SQPDATETIME_H |
|
3 | 3 | |
|
4 | 4 | #include <QObject> |
|
5 | ||
|
6 | #include <QDateTime> | |
|
7 | #include <QDebug> | |
|
8 | ||
|
5 | 9 | /** |
|
6 | 10 | * @brief The SqpDateTime struct holds the information of time parameters |
|
7 | 11 | */ |
@@ -22,6 +26,16 struct SqpDateTime { | |||
|
22 | 26 | } |
|
23 | 27 | }; |
|
24 | 28 | |
|
29 | inline QDebug operator<<(QDebug d, SqpDateTime obj) | |
|
30 | { | |
|
31 | auto tendDateTimeStart = QDateTime::fromMSecsSinceEpoch(obj.m_TStart * 1000); | |
|
32 | auto tendDateTimeEnd = QDateTime::fromMSecsSinceEpoch(obj.m_TEnd * 1000); | |
|
33 | ||
|
34 | // QDebug << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd; | |
|
35 | d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd; | |
|
36 | return d; | |
|
37 | } | |
|
38 | ||
|
25 | 39 | // Required for using shared_ptr in signals/slots |
|
26 | 40 | Q_DECLARE_METATYPE(SqpDateTime) |
|
27 | 41 |
@@ -42,7 +42,7 public slots: | |||
|
42 | 42 | void onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept; |
|
43 | 43 | |
|
44 | 44 | signals: |
|
45 |
void |
|
|
45 | void updated(); | |
|
46 | 46 | |
|
47 | 47 | |
|
48 | 48 | private: |
@@ -5,10 +5,15 | |||
|
5 | 5 | |
|
6 | 6 | #include <Data/SqpDateTime.h> |
|
7 | 7 | |
|
8 | #include <QLoggingCategory> | |
|
9 | ||
|
8 | 10 | #include <Common/spimpl.h> |
|
9 | 11 | |
|
10 | 12 | class Variable; |
|
11 | 13 | |
|
14 | Q_DECLARE_LOGGING_CATEGORY(LOG_VariableCacheController) | |
|
15 | ||
|
16 | ||
|
12 | 17 | /// This class aims to store in the cache all of the dateTime already requested to the variable. |
|
13 | 18 | class VariableCacheController : public QObject { |
|
14 | 19 | Q_OBJECT |
@@ -25,6 +30,8 public: | |||
|
25 | 30 | |
|
26 | 31 | QVector<SqpDateTime> dateCacheList(std::shared_ptr<Variable> variable) const noexcept; |
|
27 | 32 | |
|
33 | void displayCache(std::shared_ptr<Variable> variable); | |
|
34 | ||
|
28 | 35 | private: |
|
29 | 36 | class VariableCacheControllerPrivate; |
|
30 | 37 | spimpl::unique_impl_ptr<VariableCacheControllerPrivate> impl; |
@@ -30,14 +30,13 public: | |||
|
30 | 30 | void setTimeController(TimeController *timeController) noexcept; |
|
31 | 31 | |
|
32 | 32 | |
|
33 | /// Request the data loading of the variable whithin dateTime | |
|
34 | void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime); | |
|
35 | ||
|
36 | 33 | signals: |
|
37 | 34 | /// Signal emitted when a variable has been created |
|
38 | 35 | void variableCreated(std::shared_ptr<Variable> variable); |
|
39 | 36 | |
|
40 | 37 | public slots: |
|
38 | /// Request the data loading of the variable whithin dateTime | |
|
39 | void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime); | |
|
41 | 40 | /** |
|
42 | 41 | * Creates a new variable and adds it to the model |
|
43 | 42 | * @param name the name of the new variable |
@@ -67,7 +67,7 void Variable::onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept | |||
|
67 | 67 | if (impl->m_DataSeries) { |
|
68 | 68 | impl->m_DataSeries->merge(dataSeries.get()); |
|
69 | 69 | |
|
70 |
emit |
|
|
70 | emit updated(); | |
|
71 | 71 | } |
|
72 | 72 | } |
|
73 | 73 |
@@ -3,6 +3,8 | |||
|
3 | 3 | #include "Variable/Variable.h" |
|
4 | 4 | #include <unordered_map> |
|
5 | 5 | |
|
6 | Q_LOGGING_CATEGORY(LOG_VariableCacheController, "VariableCacheController") | |
|
7 | ||
|
6 | 8 | struct VariableCacheController::VariableCacheControllerPrivate { |
|
7 | 9 | |
|
8 | 10 | std::unordered_map<std::shared_ptr<Variable>, QVector<SqpDateTime> > |
@@ -156,15 +158,26 void VariableCacheController::VariableCacheControllerPrivate::addInCacheDataBySt | |||
|
156 | 158 | // ts localised between to interval: let's localized te |
|
157 | 159 | addInCacheDataByEnd(dateTime, dateTimeList, notInCache, cacheIndex, currentTStart); |
|
158 | 160 | } |
|
159 |
else if ( |
|
|
161 | else if (currentTStart < currentDateTimeI.m_TEnd) { | |
|
162 | if (dateTime.m_TEnd > currentDateTimeI.m_TEnd) { | |
|
160 | 163 | // ts not localised before the current interval: we need to look at the next interval |
|
161 |
// We can assume now current tstart is the last interval tend, because data between them |
|
|
164 | // We can assume now current tstart is the last interval tend, because data between them | |
|
165 | // are | |
|
162 | 166 | // in the cache |
|
163 | 167 | addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex, |
|
164 | 168 | currentDateTimeI.m_TEnd); |
|
165 | 169 | } |
|
170 | } | |
|
166 | 171 | else { |
|
167 | 172 | // ts not localised before the current interval: we need to look at the next interval |
|
168 | 173 | addInCacheDataByStart(dateTime, dateTimeList, notInCache, ++cacheIndex, currentTStart); |
|
169 | 174 | } |
|
170 | 175 | } |
|
176 | ||
|
177 | ||
|
178 | void VariableCacheController::displayCache(std::shared_ptr<Variable> variable) | |
|
179 | { | |
|
180 | auto variableDateTimeList = impl->m_VariableToSqpDateTimeListMap.at(variable); | |
|
181 | qCInfo(LOG_VariableCacheController()) << tr("VariableCacheController::displayCache") | |
|
182 | << variableDateTimeList; | |
|
183 | } |
@@ -9,7 +9,6 | |||
|
9 | 9 | #include <Time/TimeController.h> |
|
10 | 10 | |
|
11 | 11 | #include <QDateTime> |
|
12 | #include <QElapsedTimer> | |
|
13 | 12 | #include <QMutex> |
|
14 | 13 | #include <QThread> |
|
15 | 14 | |
@@ -112,7 +111,7 void VariableController::createVariable(const QString &name, | |||
|
112 | 111 | } |
|
113 | 112 | |
|
114 | 113 | |
|
115 |
void VariableController:: |
|
|
114 | void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable, | |
|
116 | 115 | const SqpDateTime &dateTime) |
|
117 | 116 | { |
|
118 | 117 | // we want to load data of the variable for the dateTime. |
@@ -120,25 +119,19 void VariableController::requestDataLoading(std::shared_ptr<Variable> variable, | |||
|
120 | 119 | // For the other, we ask the provider to give them. |
|
121 | 120 | if (variable) { |
|
122 | 121 | |
|
123 | QElapsedTimer timer; | |
|
124 | timer.start(); | |
|
125 | qCInfo(LOG_VariableController()) << "TORM: The slow s0 operation took" << timer.elapsed() | |
|
126 | << "milliseconds"; | |
|
127 | 122 | auto dateTimeListNotInCache |
|
128 | 123 | = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime); |
|
129 | qCInfo(LOG_VariableController()) << "TORM: The slow s1 operation took" << timer.elapsed() | |
|
130 | << "milliseconds"; | |
|
131 | 124 | |
|
125 | if (!dateTimeListNotInCache.empty()) { | |
|
132 | 126 | // Ask the provider for each data on the dateTimeListNotInCache |
|
133 |
impl->m_VariableToProviderMap.at(variable)->requestDataLoading( |
|
|
134 | ||
|
135 | qCInfo(LOG_VariableController()) << "TORM: The slow s2 operation took" << timer.elapsed() | |
|
136 | << "milliseconds"; | |
|
137 | ||
|
127 | impl->m_VariableToProviderMap.at(variable)->requestDataLoading( | |
|
128 | std::move(dateTimeListNotInCache)); | |
|
138 | 129 | // store in cache |
|
139 | 130 | impl->m_VariableCacheController->addDateTime(variable, dateTime); |
|
140 | qCInfo(LOG_VariableController()) << "TORM: The slow s3 operation took" << timer.elapsed() | |
|
141 | << "milliseconds"; | |
|
131 | } | |
|
132 | else { | |
|
133 | emit variable->updated(); | |
|
134 | } | |
|
142 | 135 | } |
|
143 | 136 | else { |
|
144 | 137 | qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null"); |
@@ -241,6 +241,16 void TestVariableCacheController::testProvideNotInCacheDateTimeList() | |||
|
241 | 241 | notInCacheSqp = notInCach.at(1); |
|
242 | 242 | QCOMPARE(notInCacheSqp.m_TStart, static_cast<double>(te1.toMSecsSinceEpoch())); |
|
243 | 243 | QCOMPARE(notInCacheSqp.m_TEnd, static_cast<double>(te.toMSecsSinceEpoch())); |
|
244 | ||
|
245 | ||
|
246 | // 12th case ts0 < ts < te0 | |
|
247 | ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 10, 0}}; | |
|
248 | te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 50, 0}}; | |
|
249 | sqp = SqpDateTime{static_cast<double>(ts.toMSecsSinceEpoch()), | |
|
250 | static_cast<double>(te.toMSecsSinceEpoch())}; | |
|
251 | ||
|
252 | notInCach = variableCacheController.provideNotInCacheDateTimeList(var0, sqp); | |
|
253 | QCOMPARE(notInCach.size(), 0); | |
|
244 | 254 | } |
|
245 | 255 | |
|
246 | 256 |
@@ -13,6 +13,7 | |||
|
13 | 13 | Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget) |
|
14 | 14 | |
|
15 | 15 | class QCPRange; |
|
16 | class SqpDateTime; | |
|
16 | 17 | class Variable; |
|
17 | 18 | |
|
18 | 19 | namespace Ui { |
@@ -37,6 +38,9 public: | |||
|
37 | 38 | |
|
38 | 39 | void updateDisplay(std::shared_ptr<Variable> variable); |
|
39 | 40 | |
|
41 | signals: | |
|
42 | void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime); | |
|
43 | ||
|
40 | 44 | |
|
41 | 45 | private: |
|
42 | 46 | Ui::VisualizationGraphWidget *ui; |
@@ -37,30 +37,32 void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSerie | |||
|
37 | 37 | timer.start(); |
|
38 | 38 | if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) { |
|
39 | 39 | // Clean the graph |
|
40 | qCDebug(LOG_VisualizationGraphHelper()) << "The slow s1 operation took" << timer.elapsed() | |
|
41 | << "milliseconds"; | |
|
42 | 40 | // NAIVE approch |
|
43 | 41 | const auto &xData = scalarSeries.xAxisData()->data(); |
|
44 | 42 | const auto &valuesData = scalarSeries.valuesData()->data(); |
|
43 | const auto count = xData.count(); | |
|
44 | qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache" << xData.count(); | |
|
45 | 45 | |
|
46 | auto xValue = QVector<double>(); | |
|
47 | auto vValue = QVector<double>(); | |
|
46 | auto xValue = QVector<double>(count); | |
|
47 | auto vValue = QVector<double>(count); | |
|
48 | 48 | |
|
49 | const auto count = xData.count(); | |
|
50 | auto ite = 0; | |
|
49 | int n = 0; | |
|
51 | 50 | for (auto i = 0; i < count; ++i) { |
|
52 |
const auto x = xData |
|
|
51 | const auto x = xData[i]; | |
|
53 | 52 | if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) { |
|
54 |
xValue |
|
|
55 |
vValue |
|
|
56 |
++ |
|
|
53 | xValue[n] = x; | |
|
54 | vValue[n] = valuesData[i]; | |
|
55 | ++n; | |
|
57 | 56 | } |
|
58 | 57 | } |
|
59 | 58 | |
|
60 | qcpGraph->setData(xValue, vValue); | |
|
59 | xValue.resize(n); | |
|
60 | vValue.resize(n); | |
|
61 | 61 | |
|
62 |
qC |
|
|
63 |
|
|
|
62 | qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed" | |
|
63 | << xValue.count(); | |
|
64 | ||
|
65 | qcpGraph->setData(xValue, vValue); | |
|
64 | 66 | } |
|
65 | 67 | else { |
|
66 | 68 | /// @todo DEBUG |
@@ -57,6 +57,9 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget | |||
|
57 | 57 | ui->widget->setContextMenuPolicy(Qt::CustomContextMenu); |
|
58 | 58 | connect(ui->widget, &QCustomPlot::customContextMenuRequested, this, |
|
59 | 59 | &VisualizationGraphWidget::onGraphMenuRequested); |
|
60 | ||
|
61 | connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(), | |
|
62 | &VariableController::onRequestDataLoading); | |
|
60 | 63 | } |
|
61 | 64 | |
|
62 | 65 | |
@@ -74,7 +77,7 void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable) | |||
|
74 | 77 | impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable}); |
|
75 | 78 | } |
|
76 | 79 | |
|
77 |
connect(variable.get(), SIGNAL( |
|
|
80 | connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated())); | |
|
78 | 81 | } |
|
79 | 82 | |
|
80 | 83 | void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept |
@@ -142,9 +145,6 void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange | |||
|
142 | 145 | it != impl->m_VariableToPlotMultiMap.cend(); ++it) { |
|
143 | 146 | |
|
144 | 147 | auto variable = it->first; |
|
145 | qCInfo(LOG_VisualizationGraphWidget()) | |
|
146 | << tr("TORM: VisualizationGraphWidget::onRangeChanged") | |
|
147 | << variable->dataSeries()->xAxisData()->size(); | |
|
148 | 148 | auto dateTime = SqpDateTime{t2.lower, t2.upper}; |
|
149 | 149 | |
|
150 | 150 | if (!variable->contains(dateTime)) { |
@@ -179,8 +179,7 void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange | |||
|
179 | 179 | variable->setDateTime(dateTime); |
|
180 | 180 | |
|
181 | 181 | // CHangement detected, we need to ask controller to request data loading |
|
182 | sqpApp->variableController().requestDataLoading(variable, | |
|
183 | variableDateTimeWithTolerance); | |
|
182 | emit requestDataLoading(variable, variableDateTimeWithTolerance); | |
|
184 | 183 | } |
|
185 | 184 | } |
|
186 | 185 | } |
@@ -5,6 +5,8 | |||
|
5 | 5 | |
|
6 | 6 | #include <cmath> |
|
7 | 7 | |
|
8 | #include <QDateTime> | |
|
9 | ||
|
8 | 10 | Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider") |
|
9 | 11 | |
|
10 | 12 | std::unique_ptr<IDataSeries> |
@@ -16,6 +18,7 CosinusProvider::retrieveData(const DataProviderParameters ¶meters) const | |||
|
16 | 18 | auto start = dateTime.m_TStart; |
|
17 | 19 | auto end = dateTime.m_TEnd; |
|
18 | 20 | |
|
21 | ||
|
19 | 22 | // We assure that timerange is valid |
|
20 | 23 | if (end < start) { |
|
21 | 24 | std::swap(start, end); |
@@ -47,10 +50,12 void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeLis | |||
|
47 | 50 | |
|
48 | 51 | std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTime &dateTime) |
|
49 | 52 | { |
|
53 | auto dataIndex = 0; | |
|
50 | 54 | |
|
51 | 55 | // Gets the timerange from the parameters |
|
52 | auto start = dateTime.m_TStart; | |
|
53 | auto end = dateTime.m_TEnd; | |
|
56 | double freq = 100.0; | |
|
57 | double start = dateTime.m_TStart * freq; // 100 htz | |
|
58 | double end = dateTime.m_TEnd * freq; // 100 htz | |
|
54 | 59 | |
|
55 | 60 | // We assure that timerange is valid |
|
56 | 61 | if (end < start) { |
@@ -61,11 +66,9 std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTi | |||
|
61 | 66 | auto scalarSeries |
|
62 | 67 | = std::make_shared<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{}); |
|
63 | 68 | |
|
64 | auto dataIndex = 0; | |
|
65 | 69 | for (auto time = start; time < end; ++time, ++dataIndex) { |
|
66 | scalarSeries->setData(dataIndex, time, std::cos(time)); | |
|
70 | const auto timeOnFreq = time / freq; | |
|
71 | scalarSeries->setData(dataIndex, timeOnFreq, std::cos(timeOnFreq)); | |
|
67 | 72 | } |
|
68 | ||
|
69 | ||
|
70 | 73 | return scalarSeries; |
|
71 | 74 | } |
General Comments 0
You need to be logged in to leave comments.
Login now