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

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Implementation of V5 acquisition
perrinel -
r510:7c107b5923b0
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,180 +1,190
1 #ifndef SCIQLOP_DATASERIES_H
1 #ifndef SCIQLOP_DATASERIES_H
2 #define SCIQLOP_DATASERIES_H
2 #define SCIQLOP_DATASERIES_H
3
3
4 #include <Common/SortUtils.h>
4 #include <Common/SortUtils.h>
5
5
6 #include <Data/ArrayData.h>
6 #include <Data/ArrayData.h>
7 #include <Data/IDataSeries.h>
7 #include <Data/IDataSeries.h>
8
8
9 #include <QLoggingCategory>
9 #include <QLoggingCategory>
10
10
11 #include <QReadLocker>
11 #include <QReadLocker>
12 #include <QReadWriteLock>
12 #include <QReadWriteLock>
13 #include <memory>
13 #include <memory>
14
14
15 Q_DECLARE_LOGGING_CATEGORY(LOG_DataSeries)
15 Q_DECLARE_LOGGING_CATEGORY(LOG_DataSeries)
16 Q_LOGGING_CATEGORY(LOG_DataSeries, "DataSeries")
16 Q_LOGGING_CATEGORY(LOG_DataSeries, "DataSeries")
17
17
18
18
19 /**
19 /**
20 * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
20 * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
21 *
21 *
22 * It proposes to set a dimension for the values ​​data.
22 * It proposes to set a dimension for the values ​​data.
23 *
23 *
24 * A DataSeries is always sorted on its x-axis data.
24 * A DataSeries is always sorted on its x-axis data.
25 *
25 *
26 * @tparam Dim The dimension of the values data
26 * @tparam Dim The dimension of the values data
27 *
27 *
28 */
28 */
29 template <int Dim>
29 template <int Dim>
30 class DataSeries : public IDataSeries {
30 class DataSeries : public IDataSeries {
31 public:
31 public:
32 /// @sa IDataSeries::xAxisData()
32 /// @sa IDataSeries::xAxisData()
33 std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
33 std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
34 const std::shared_ptr<ArrayData<1> > xAxisData() const { return m_XAxisData; }
34 const std::shared_ptr<ArrayData<1> > xAxisData() const { return m_XAxisData; }
35
35
36 /// @sa IDataSeries::xAxisUnit()
36 /// @sa IDataSeries::xAxisUnit()
37 Unit xAxisUnit() const override { return m_XAxisUnit; }
37 Unit xAxisUnit() const override { return m_XAxisUnit; }
38
38
39 /// @return the values dataset
39 /// @return the values dataset
40 std::shared_ptr<ArrayData<Dim> > valuesData() { return m_ValuesData; }
40 std::shared_ptr<ArrayData<Dim> > valuesData() { return m_ValuesData; }
41 const std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
41 const std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
42
42
43 /// @sa IDataSeries::valuesUnit()
43 /// @sa IDataSeries::valuesUnit()
44 Unit valuesUnit() const override { return m_ValuesUnit; }
44 Unit valuesUnit() const override { return m_ValuesUnit; }
45
45
46
47 SqpRange range() const override
48 {
49 if (!m_XAxisData->cdata().isEmpty()) {
50 return SqpRange{m_XAxisData->cdata().first(), m_XAxisData->cdata().last()};
51 }
52
53 return SqpRange{};
54 }
55
46 void clear()
56 void clear()
47 {
57 {
48 m_XAxisData->clear();
58 m_XAxisData->clear();
49 m_ValuesData->clear();
59 m_ValuesData->clear();
50 }
60 }
51
61
52 /// Merges into the data series an other data series
62 /// Merges into the data series an other data series
53 /// @remarks the data series to merge with is cleared after the operation
63 /// @remarks the data series to merge with is cleared after the operation
54 void merge(IDataSeries *dataSeries) override
64 void merge(IDataSeries *dataSeries) override
55 {
65 {
56 dataSeries->lockWrite();
66 dataSeries->lockWrite();
57 lockWrite();
67 lockWrite();
58
68
59 if (auto other = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
69 if (auto other = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
60 const auto &otherXAxisData = other->xAxisData()->cdata();
70 const auto &otherXAxisData = other->xAxisData()->cdata();
61 const auto &xAxisData = m_XAxisData->cdata();
71 const auto &xAxisData = m_XAxisData->cdata();
62
72
63 // As data series are sorted, we can improve performances of merge, by call the sort
73 // As data series are sorted, we can improve performances of merge, by call the sort
64 // method only if the two data series overlap.
74 // method only if the two data series overlap.
65 if (!otherXAxisData.empty()) {
75 if (!otherXAxisData.empty()) {
66 auto firstValue = otherXAxisData.front();
76 auto firstValue = otherXAxisData.front();
67 auto lastValue = otherXAxisData.back();
77 auto lastValue = otherXAxisData.back();
68
78
69 auto xAxisDataBegin = xAxisData.cbegin();
79 auto xAxisDataBegin = xAxisData.cbegin();
70 auto xAxisDataEnd = xAxisData.cend();
80 auto xAxisDataEnd = xAxisData.cend();
71
81
72 bool prepend;
82 bool prepend;
73 bool sortNeeded;
83 bool sortNeeded;
74
84
75 if (std::lower_bound(xAxisDataBegin, xAxisDataEnd, firstValue) == xAxisDataEnd) {
85 if (std::lower_bound(xAxisDataBegin, xAxisDataEnd, firstValue) == xAxisDataEnd) {
76 // Other data series if after data series
86 // Other data series if after data series
77 prepend = false;
87 prepend = false;
78 sortNeeded = false;
88 sortNeeded = false;
79 }
89 }
80 else if (std::upper_bound(xAxisDataBegin, xAxisDataEnd, lastValue)
90 else if (std::upper_bound(xAxisDataBegin, xAxisDataEnd, lastValue)
81 == xAxisDataBegin) {
91 == xAxisDataBegin) {
82 // Other data series if before data series
92 // Other data series if before data series
83 prepend = true;
93 prepend = true;
84 sortNeeded = false;
94 sortNeeded = false;
85 }
95 }
86 else {
96 else {
87 // The two data series overlap
97 // The two data series overlap
88 prepend = false;
98 prepend = false;
89 sortNeeded = true;
99 sortNeeded = true;
90 }
100 }
91
101
92 // Makes the merge
102 // Makes the merge
93 m_XAxisData->add(*other->xAxisData(), prepend);
103 m_XAxisData->add(*other->xAxisData(), prepend);
94 m_ValuesData->add(*other->valuesData(), prepend);
104 m_ValuesData->add(*other->valuesData(), prepend);
95
105
96 if (sortNeeded) {
106 if (sortNeeded) {
97 sort();
107 sort();
98 }
108 }
99 }
109 }
100
110
101 // Clears the other data series
111 // Clears the other data series
102 other->clear();
112 other->clear();
103 }
113 }
104 else {
114 else {
105 qCWarning(LOG_DataSeries())
115 qCWarning(LOG_DataSeries())
106 << QObject::tr("Detection of a type of IDataSeries we cannot merge with !");
116 << QObject::tr("Detection of a type of IDataSeries we cannot merge with !");
107 }
117 }
108 unlock();
118 unlock();
109 dataSeries->unlock();
119 dataSeries->unlock();
110 }
120 }
111
121
112 virtual void lockRead() { m_Lock.lockForRead(); }
122 virtual void lockRead() { m_Lock.lockForRead(); }
113 virtual void lockWrite() { m_Lock.lockForWrite(); }
123 virtual void lockWrite() { m_Lock.lockForWrite(); }
114 virtual void unlock() { m_Lock.unlock(); }
124 virtual void unlock() { m_Lock.unlock(); }
115
125
116 protected:
126 protected:
117 /// Protected ctor (DataSeries is abstract). The vectors must have the same size, otherwise a
127 /// Protected ctor (DataSeries is abstract). The vectors must have the same size, otherwise a
118 /// DataSeries with no values will be created.
128 /// DataSeries with no values will be created.
119 /// @remarks data series is automatically sorted on its x-axis data
129 /// @remarks data series is automatically sorted on its x-axis data
120 explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
130 explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
121 std::shared_ptr<ArrayData<Dim> > valuesData, const Unit &valuesUnit)
131 std::shared_ptr<ArrayData<Dim> > valuesData, const Unit &valuesUnit)
122 : m_XAxisData{xAxisData},
132 : m_XAxisData{xAxisData},
123 m_XAxisUnit{xAxisUnit},
133 m_XAxisUnit{xAxisUnit},
124 m_ValuesData{valuesData},
134 m_ValuesData{valuesData},
125 m_ValuesUnit{valuesUnit}
135 m_ValuesUnit{valuesUnit}
126 {
136 {
127 if (m_XAxisData->size() != m_ValuesData->size()) {
137 if (m_XAxisData->size() != m_ValuesData->size()) {
128 clear();
138 clear();
129 }
139 }
130
140
131 // Sorts data if it's not the case
141 // Sorts data if it's not the case
132 const auto &xAxisCData = m_XAxisData->cdata();
142 const auto &xAxisCData = m_XAxisData->cdata();
133 if (!std::is_sorted(xAxisCData.cbegin(), xAxisCData.cend())) {
143 if (!std::is_sorted(xAxisCData.cbegin(), xAxisCData.cend())) {
134 sort();
144 sort();
135 }
145 }
136 }
146 }
137
147
138 /// Copy ctor
148 /// Copy ctor
139 explicit DataSeries(const DataSeries<Dim> &other)
149 explicit DataSeries(const DataSeries<Dim> &other)
140 : m_XAxisData{std::make_shared<ArrayData<1> >(*other.m_XAxisData)},
150 : m_XAxisData{std::make_shared<ArrayData<1> >(*other.m_XAxisData)},
141 m_XAxisUnit{other.m_XAxisUnit},
151 m_XAxisUnit{other.m_XAxisUnit},
142 m_ValuesData{std::make_shared<ArrayData<Dim> >(*other.m_ValuesData)},
152 m_ValuesData{std::make_shared<ArrayData<Dim> >(*other.m_ValuesData)},
143 m_ValuesUnit{other.m_ValuesUnit}
153 m_ValuesUnit{other.m_ValuesUnit}
144 {
154 {
145 // Since a series is ordered from its construction and is always ordered, it is not
155 // Since a series is ordered from its construction and is always ordered, it is not
146 // necessary to call the sort method here ('other' is sorted)
156 // necessary to call the sort method here ('other' is sorted)
147 }
157 }
148
158
149 /// Assignment operator
159 /// Assignment operator
150 template <int D>
160 template <int D>
151 DataSeries &operator=(DataSeries<D> other)
161 DataSeries &operator=(DataSeries<D> other)
152 {
162 {
153 std::swap(m_XAxisData, other.m_XAxisData);
163 std::swap(m_XAxisData, other.m_XAxisData);
154 std::swap(m_XAxisUnit, other.m_XAxisUnit);
164 std::swap(m_XAxisUnit, other.m_XAxisUnit);
155 std::swap(m_ValuesData, other.m_ValuesData);
165 std::swap(m_ValuesData, other.m_ValuesData);
156 std::swap(m_ValuesUnit, other.m_ValuesUnit);
166 std::swap(m_ValuesUnit, other.m_ValuesUnit);
157
167
158 return *this;
168 return *this;
159 }
169 }
160
170
161 private:
171 private:
162 /**
172 /**
163 * Sorts data series on its x-axis data
173 * Sorts data series on its x-axis data
164 */
174 */
165 void sort() noexcept
175 void sort() noexcept
166 {
176 {
167 auto permutation = SortUtils::sortPermutation(*m_XAxisData, std::less<double>());
177 auto permutation = SortUtils::sortPermutation(*m_XAxisData, std::less<double>());
168 m_XAxisData = m_XAxisData->sort(permutation);
178 m_XAxisData = m_XAxisData->sort(permutation);
169 m_ValuesData = m_ValuesData->sort(permutation);
179 m_ValuesData = m_ValuesData->sort(permutation);
170 }
180 }
171
181
172 std::shared_ptr<ArrayData<1> > m_XAxisData;
182 std::shared_ptr<ArrayData<1> > m_XAxisData;
173 Unit m_XAxisUnit;
183 Unit m_XAxisUnit;
174 std::shared_ptr<ArrayData<Dim> > m_ValuesData;
184 std::shared_ptr<ArrayData<Dim> > m_ValuesData;
175 Unit m_ValuesUnit;
185 Unit m_ValuesUnit;
176
186
177 QReadWriteLock m_Lock;
187 QReadWriteLock m_Lock;
178 };
188 };
179
189
180 #endif // SCIQLOP_DATASERIES_H
190 #endif // SCIQLOP_DATASERIES_H
Show file before | Show file after | Hide comments
@@ -1,74 +1,76
1 #ifndef SCIQLOP_IDATAPROVIDER_H
1 #ifndef SCIQLOP_IDATAPROVIDER_H
2 #define SCIQLOP_IDATAPROVIDER_H
2 #define SCIQLOP_IDATAPROVIDER_H
3
3
4 #include "CoreGlobal.h"
4 #include "CoreGlobal.h"
5
5
6 #include <memory>
6 #include <memory>
7
7
8 #include <QObject>
8 #include <QObject>
9 #include <QUuid>
9 #include <QUuid>
10
10
11 #include <Common/MetaTypes.h>
11 #include <Common/MetaTypes.h>
12
12
13 #include <Data/SqpRange.h>
13 #include <Data/SqpRange.h>
14
14
15 #include <functional>
15 #include <functional>
16
16
17 class DataProviderParameters;
17 class DataProviderParameters;
18 class IDataSeries;
18 class IDataSeries;
19 class QNetworkReply;
19 class QNetworkReply;
20 class QNetworkRequest;
20 class QNetworkRequest;
21
21
22 /**
22 /**
23 * @brief The IDataProvider interface aims to declare a data provider.
23 * @brief The IDataProvider interface aims to declare a data provider.
24 *
24 *
25 * A data provider is an entity that generates data and returns it according to various parameters
25 * A data provider is an entity that generates data and returns it according to various parameters
26 * (time interval, product to retrieve the data, etc.)
26 * (time interval, product to retrieve the data, etc.)
27 *
27 *
28 * @sa IDataSeries
28 * @sa IDataSeries
29 */
29 */
30 class SCIQLOP_CORE_EXPORT IDataProvider : public QObject {
30 class SCIQLOP_CORE_EXPORT IDataProvider : public QObject {
31
31
32 Q_OBJECT
32 Q_OBJECT
33 public:
33 public:
34 virtual ~IDataProvider() noexcept = default;
34 virtual ~IDataProvider() noexcept = default;
35
35
36 /**
36 /**
37 * @brief requestDataLoading provide datas for the data identified by identifier and parameters
37 * @brief requestDataLoading provide datas for the data identified by acqIdentifier and
38 * parameters
38 */
39 */
39 virtual void requestDataLoading(QUuid identifier, const DataProviderParameters &parameters) = 0;
40 virtual void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters)
41 = 0;
40
42
41 /**
43 /**
42 * @brief requestDataAborting stop data loading of the data identified by identifier
44 * @brief requestDataAborting stop data loading of the data identified by acqIdentifier
43 */
45 */
44 virtual void requestDataAborting(QUuid identifier) = 0;
46 virtual void requestDataAborting(QUuid acqIdentifier) = 0;
45
47
46 signals:
48 signals:
47 /**
49 /**
48 * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
50 * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
49 * identified by identifier
51 * identified by acqIdentifier
50 */
52 */
51 void dataProvided(QUuid identifier, std::shared_ptr<IDataSeries> dateSerie,
53 void dataProvided(QUuid acqIdentifier, std::shared_ptr<IDataSeries> dateSeriesAcquired,
52 const SqpRange &dateTime);
54 const SqpRange &dataRangeAcquired);
53
55
54 /**
56 /**
55 * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
57 * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
56 * identified by identifier
58 * identified by identifier
57 */
59 */
58 void dataProvidedProgress(QUuid identifier, double progress);
60 void dataProvidedProgress(QUuid acqIdentifier, double progress);
59
61
60
62
61 /**
63 /**
62 * @brief requestConstructed send a request for the data identified by identifier
64 * @brief requestConstructed send a request for the data identified by acqIdentifier
63 * @callback is the methode call by the reply of the request when it is finished.
65 * @callback is the methode call by the reply of the request when it is finished.
64 */
66 */
65 void requestConstructed(const QNetworkRequest &request, QUuid identifier,
67 void requestConstructed(const QNetworkRequest &request, QUuid acqIdentifier,
66 std::function<void(QNetworkReply *, QUuid)> callback);
68 std::function<void(QNetworkReply *, QUuid)> callback);
67 };
69 };
68
70
69 // Required for using shared_ptr in signals/slots
71 // Required for using shared_ptr in signals/slots
70 SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY, std::shared_ptr<IDataProvider>)
72 SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY, std::shared_ptr<IDataProvider>)
71 SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_FUNCTION_REGISTRY,
73 SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_FUNCTION_REGISTRY,
72 std::function<void(QNetworkReply *, QUuid)>)
74 std::function<void(QNetworkReply *, QUuid)>)
73
75
74 #endif // SCIQLOP_IDATAPROVIDER_H
76 #endif // SCIQLOP_IDATAPROVIDER_H
Show file before | Show file after | Hide comments
@@ -1,69 +1,72
1 #ifndef SCIQLOP_IDATASERIES_H
1 #ifndef SCIQLOP_IDATASERIES_H
2 #define SCIQLOP_IDATASERIES_H
2 #define SCIQLOP_IDATASERIES_H
3
3
4 #include <Common/MetaTypes.h>
4 #include <Common/MetaTypes.h>
5 #include <Data/SqpRange.h>
5
6
6 #include <memory>
7 #include <memory>
7
8
8 #include <QString>
9 #include <QString>
9
10
10 template <int Dim>
11 template <int Dim>
11 class ArrayData;
12 class ArrayData;
12
13
13 struct Unit {
14 struct Unit {
14 explicit Unit(const QString &name = {}, bool timeUnit = false)
15 explicit Unit(const QString &name = {}, bool timeUnit = false)
15 : m_Name{name}, m_TimeUnit{timeUnit}
16 : m_Name{name}, m_TimeUnit{timeUnit}
16 {
17 {
17 }
18 }
18
19
19 inline bool operator==(const Unit &other) const
20 inline bool operator==(const Unit &other) const
20 {
21 {
21 return std::tie(m_Name, m_TimeUnit) == std::tie(other.m_Name, other.m_TimeUnit);
22 return std::tie(m_Name, m_TimeUnit) == std::tie(other.m_Name, other.m_TimeUnit);
22 }
23 }
23 inline bool operator!=(const Unit &other) const { return !(*this == other); }
24 inline bool operator!=(const Unit &other) const { return !(*this == other); }
24
25
25 QString m_Name; ///< Unit name
26 QString m_Name; ///< Unit name
26 bool m_TimeUnit; ///< The unit is a unit of time (UTC)
27 bool m_TimeUnit; ///< The unit is a unit of time (UTC)
27 };
28 };
28
29
29 /**
30 /**
30 * @brief The IDataSeries aims to declare a data series.
31 * @brief The IDataSeries aims to declare a data series.
31 *
32 *
32 * A data series is an entity that contains at least :
33 * A data series is an entity that contains at least :
33 * - one dataset representing the x-axis
34 * - one dataset representing the x-axis
34 * - one dataset representing the values
35 * - one dataset representing the values
35 *
36 *
36 * Each dataset is represented by an ArrayData, and is associated with a unit.
37 * Each dataset is represented by an ArrayData, and is associated with a unit.
37 *
38 *
38 * An ArrayData can be unidimensional or two-dimensional, depending on the implementation of the
39 * An ArrayData can be unidimensional or two-dimensional, depending on the implementation of the
39 * IDataSeries. The x-axis dataset is always unidimensional.
40 * IDataSeries. The x-axis dataset is always unidimensional.
40 *
41 *
41 * @sa ArrayData
42 * @sa ArrayData
42 */
43 */
43 class IDataSeries {
44 class IDataSeries {
44 public:
45 public:
45 virtual ~IDataSeries() noexcept = default;
46 virtual ~IDataSeries() noexcept = default;
46
47
47 /// Returns the x-axis dataset
48 /// Returns the x-axis dataset
48 virtual std::shared_ptr<ArrayData<1> > xAxisData() = 0;
49 virtual std::shared_ptr<ArrayData<1> > xAxisData() = 0;
49
50
50 /// Returns the x-axis dataset (as const)
51 /// Returns the x-axis dataset (as const)
51 virtual const std::shared_ptr<ArrayData<1> > xAxisData() const = 0;
52 virtual const std::shared_ptr<ArrayData<1> > xAxisData() const = 0;
52
53
53 virtual Unit xAxisUnit() const = 0;
54 virtual Unit xAxisUnit() const = 0;
54
55
55 virtual Unit valuesUnit() const = 0;
56 virtual Unit valuesUnit() const = 0;
56
57
57 virtual void merge(IDataSeries *dataSeries) = 0;
58 virtual void merge(IDataSeries *dataSeries) = 0;
59 virtual std::shared_ptr<IDataSeries> subData(const SqpRange &range) = 0;
58
60
59 virtual std::unique_ptr<IDataSeries> clone() const = 0;
61 virtual std::unique_ptr<IDataSeries> clone() const = 0;
62 virtual SqpRange range() const = 0;
60
63
61 virtual void lockRead() = 0;
64 virtual void lockRead() = 0;
62 virtual void lockWrite() = 0;
65 virtual void lockWrite() = 0;
63 virtual void unlock() = 0;
66 virtual void unlock() = 0;
64 };
67 };
65
68
66 // Required for using shared_ptr in signals/slots
69 // Required for using shared_ptr in signals/slots
67 SCIQLOP_REGISTER_META_TYPE(IDATASERIES_PTR_REGISTRY, std::shared_ptr<IDataSeries>)
70 SCIQLOP_REGISTER_META_TYPE(IDATASERIES_PTR_REGISTRY, std::shared_ptr<IDataSeries>)
68
71
69 #endif // SCIQLOP_IDATASERIES_H
72 #endif // SCIQLOP_IDATASERIES_H
Show file before | Show file after | Hide comments
@@ -1,25 +1,27
1 #ifndef SCIQLOP_SCALARSERIES_H
1 #ifndef SCIQLOP_SCALARSERIES_H
2 #define SCIQLOP_SCALARSERIES_H
2 #define SCIQLOP_SCALARSERIES_H
3
3
4 #include "CoreGlobal.h"
4 #include "CoreGlobal.h"
5
5
6 #include <Data/DataSeries.h>
6 #include <Data/DataSeries.h>
7
7
8 /**
8 /**
9 * @brief The ScalarSeries class is the implementation for a data series representing a scalar.
9 * @brief The ScalarSeries class is the implementation for a data series representing a scalar.
10 */
10 */
11 class SCIQLOP_CORE_EXPORT ScalarSeries : public DataSeries<1> {
11 class SCIQLOP_CORE_EXPORT ScalarSeries : public DataSeries<1> {
12 public:
12 public:
13 /**
13 /**
14 * Ctor with two vectors. The vectors must have the same size, otherwise a ScalarSeries with no
14 * Ctor with two vectors. The vectors must have the same size, otherwise a ScalarSeries with no
15 * values will be created.
15 * values will be created.
16 * @param xAxisData x-axis data
16 * @param xAxisData x-axis data
17 * @param valuesData values data
17 * @param valuesData values data
18 */
18 */
19 explicit ScalarSeries(QVector<double> xAxisData, QVector<double> valuesData,
19 explicit ScalarSeries(QVector<double> xAxisData, QVector<double> valuesData,
20 const Unit &xAxisUnit, const Unit &valuesUnit);
20 const Unit &xAxisUnit, const Unit &valuesUnit);
21
21
22 std::unique_ptr<IDataSeries> clone() const;
22 std::unique_ptr<IDataSeries> clone() const override;
23
24 std::shared_ptr<IDataSeries> subData(const SqpRange &range) override;
23 };
25 };
24
26
25 #endif // SCIQLOP_SCALARSERIES_H
27 #endif // SCIQLOP_SCALARSERIES_H
Show file before | Show file after | Hide comments
@@ -1,36 +1,61
1 #ifndef SCIQLOP_VARIABLEACQUISITIONWORKER_H
1 #ifndef SCIQLOP_VARIABLEACQUISITIONWORKER_H
2 #define SCIQLOP_VARIABLEACQUISITIONWORKER_H
2 #define SCIQLOP_VARIABLEACQUISITIONWORKER_H
3
3
4 #include "CoreGlobal.h"
4 #include "CoreGlobal.h"
5
5
6 #include <Data/DataProviderParameters.h>
6 #include <Data/DataProviderParameters.h>
7 #include <QLoggingCategory>
7 #include <QLoggingCategory>
8 #include <QObject>
8 #include <QObject>
9 #include <QUuid>
9 #include <QUuid>
10
10
11 #include <Data/AcquisitionDataPacket.h>
12 #include <Data/IDataSeries.h>
11 #include <Data/SqpRange.h>
13 #include <Data/SqpRange.h>
12
14
13 #include <QLoggingCategory>
15 #include <QLoggingCategory>
14
16
15 #include <Common/spimpl.h>
17 #include <Common/spimpl.h>
16
18
17 Q_DECLARE_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker)
19 Q_DECLARE_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker)
18
20
19 class Variable;
21 class Variable;
20 class IDataProvider;
22 class IDataProvider;
21
23
22 /// This class aims to handle all acquisition request
24 /// This class aims to handle all acquisition request
23 class SCIQLOP_CORE_EXPORT VariableAcquisitionWorker : public QObject {
25 class SCIQLOP_CORE_EXPORT VariableAcquisitionWorker : public QObject {
24 Q_OBJECT
26 Q_OBJECT
25 public:
27 public:
26 explicit VariableAcquisitionWorker(QObject *parent = 0);
28 explicit VariableAcquisitionWorker(QObject *parent = 0);
29 virtual ~VariableAcquisitionWorker();
27
30
28 void pushVariableRequest(QUuid vIdentifier, SqpRange rangeRequest, SqpRange cacheRangeRequested,
31 void pushVariableRequest(QUuid vIdentifier, SqpRange rangeRequested,
29 DataProviderParameters parameters, IDataProvider *provider);
32 SqpRange cacheRangeRequested, DataProviderParameters parameters,
33 std::shared_ptr<IDataProvider> provider);
34
35 void abortProgressRequested(QUuid vIdentifier);
36
37 void initialize();
38 void finalize();
39 signals:
40 void dataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
41 const SqpRange &cacheRangeRequested,
42 QVector<AcquisitionDataPacket> dataAcquired);
43
44 void variableRequestInProgress(QUuid vIdentifier, double progress);
45
46 public slots:
47 void onVariableDataAcquired(QUuid acqIdentifier, std::shared_ptr<IDataSeries> dataSeries,
48 SqpRange dataRangeAcquired);
49 void onVariableRetrieveDataInProgress(QUuid acqIdentifier, double progress);
50
51 private slots:
52 void onExecuteRequest(QUuid acqIdentifier);
30
53
31 private:
54 private:
55 void waitForFinish();
56
32 class VariableAcquisitionWorkerPrivate;
57 class VariableAcquisitionWorkerPrivate;
33 spimpl::unique_impl_ptr<VariableAcquisitionWorkerPrivate> impl;
58 spimpl::unique_impl_ptr<VariableAcquisitionWorkerPrivate> impl;
34 };
59 };
35
60
36 #endif // SCIQLOP_VARIABLEACQUISITIONWORKER_H
61 #endif // SCIQLOP_VARIABLEACQUISITIONWORKER_H
Show file before | Show file after | Hide comments
@@ -1,97 +1,116
1 #ifndef SCIQLOP_VARIABLECONTROLLER_H
1 #ifndef SCIQLOP_VARIABLECONTROLLER_H
2 #define SCIQLOP_VARIABLECONTROLLER_H
2 #define SCIQLOP_VARIABLECONTROLLER_H
3
3
4 #include "CoreGlobal.h"
4 #include "CoreGlobal.h"
5
5
6 #include <Data/AcquisitionDataPacket.h>
6 #include <Data/SqpRange.h>
7 #include <Data/SqpRange.h>
7
8
8 #include <QLoggingCategory>
9 #include <QLoggingCategory>
9 #include <QObject>
10 #include <QObject>
10
11
11 #include <Common/spimpl.h>
12 #include <Common/spimpl.h>
12
13
13 class IDataProvider;
14 class IDataProvider;
14 class QItemSelectionModel;
15 class QItemSelectionModel;
15 class TimeController;
16 class TimeController;
16 class Variable;
17 class Variable;
17 class VariableModel;
18 class VariableModel;
18
19
19 Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
20 Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
20
21
22
23 /**
24 * Possible types of zoom operation
25 */
26 enum class AcquisitionZoomType { ZoomOut, ZoomIn, PanRight, PanLeft, Unknown };
27
28
21 /**
29 /**
22 * @brief The VariableController class aims to handle the variables in SciQlop.
30 * @brief The VariableController class aims to handle the variables in SciQlop.
23 */
31 */
24 class SCIQLOP_CORE_EXPORT VariableController : public QObject {
32 class SCIQLOP_CORE_EXPORT VariableController : public QObject {
25 Q_OBJECT
33 Q_OBJECT
26 public:
34 public:
27 explicit VariableController(QObject *parent = 0);
35 explicit VariableController(QObject *parent = 0);
28 virtual ~VariableController();
36 virtual ~VariableController();
29
37
30 VariableModel *variableModel() noexcept;
38 VariableModel *variableModel() noexcept;
31 QItemSelectionModel *variableSelectionModel() noexcept;
39 QItemSelectionModel *variableSelectionModel() noexcept;
32
40
33 void setTimeController(TimeController *timeController) noexcept;
41 void setTimeController(TimeController *timeController) noexcept;
34
42
35 /**
43 /**
36 * Deletes from the controller the variable passed in parameter.
44 * Deletes from the controller the variable passed in parameter.
37 *
45 *
38 * Delete a variable includes:
46 * Delete a variable includes:
39 * - the deletion of the various references to the variable in SciQlop
47 * - the deletion of the various references to the variable in SciQlop
40 * - the deletion of the model variable
48 * - the deletion of the model variable
41 * - the deletion of the provider associated with the variable
49 * - the deletion of the provider associated with the variable
42 * - removing the cache associated with the variable
50 * - removing the cache associated with the variable
43 *
51 *
44 * @param variable the variable to delete from the controller.
52 * @param variable the variable to delete from the controller.
45 */
53 */
46 void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
54 void deleteVariable(std::shared_ptr<Variable> variable) noexcept;
47
55
48 /**
56 /**
49 * Deletes from the controller the variables passed in parameter.
57 * Deletes from the controller the variables passed in parameter.
50 * @param variables the variables to delete from the controller.
58 * @param variables the variables to delete from the controller.
51 * @sa deleteVariable()
59 * @sa deleteVariable()
52 */
60 */
53 void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
61 void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
54
62
55 /**
63 /**
56 * @brief abort the variable retrieve data progression
64 * @brief abort the variable retrieve data progression
57 */
65 */
58 void abortProgress(std::shared_ptr<Variable> variable);
66 void abortProgress(std::shared_ptr<Variable> variable);
59
67
68 static AcquisitionZoomType getZoomType(const SqpRange &range, const SqpRange &oldRange);
60 signals:
69 signals:
61 /// Signal emitted when a variable is about to be deleted from the controller
70 /// Signal emitted when a variable is about to be deleted from the controller
62 void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
71 void variableAboutToBeDeleted(std::shared_ptr<Variable> variable);
63
72
64 /// Signal emitted when a data acquisition is requested on a range for a variable
73 /// Signal emitted when a data acquisition is requested on a range for a variable
65 void rangeChanged(std::shared_ptr<Variable> variable, const SqpRange &range);
74 void rangeChanged(std::shared_ptr<Variable> variable, const SqpRange &range);
66
75
67 public slots:
76 public slots:
68 /// Request the data loading of the variable whithin dateTime
77 /// Request the data loading of the variable whithin range
69 void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpRange &dateTime);
78 void onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables, const SqpRange &range,
79 const SqpRange &oldRange, bool synchronise);
70 /**
80 /**
71 * Creates a new variable and adds it to the model
81 * Creates a new variable and adds it to the model
72 * @param name the name of the new variable
82 * @param name the name of the new variable
73 * @param metadata the metadata of the new variable
83 * @param metadata the metadata of the new variable
74 * @param provider the data provider for the new variable
84 * @param provider the data provider for the new variable
75 */
85 */
76 void createVariable(const QString &name, const QVariantHash &metadata,
86 void createVariable(const QString &name, const QVariantHash &metadata,
77 std::shared_ptr<IDataProvider> provider) noexcept;
87 std::shared_ptr<IDataProvider> provider) noexcept;
78
88
79 /// Update the temporal parameters of every selected variable to dateTime
89 /// Update the temporal parameters of every selected variable to dateTime
80 void onDateTimeOnSelection(const SqpRange &dateTime);
90 void onDateTimeOnSelection(const SqpRange &dateTime);
81
91
82
92
93 void onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
94 const SqpRange &cacheRangeRequested,
95 QVector<AcquisitionDataPacket> dataAcquired);
96
83 void onVariableRetrieveDataInProgress(QUuid identifier, double progress);
97 void onVariableRetrieveDataInProgress(QUuid identifier, double progress);
84
98
99 /// Cancel the current request for the variable
85 void onAbortProgressRequested(std::shared_ptr<Variable> variable);
100 void onAbortProgressRequested(std::shared_ptr<Variable> variable);
86
101
102 /// synchronization group methods
103 void onAddSynchronizationGroupId(QUuid synchronizationGroupId);
104 void onRemoveSynchronizationGroupId(QUuid synchronizationGroupId);
105
87 void initialize();
106 void initialize();
88 void finalize();
107 void finalize();
89
108
90 private:
109 private:
91 void waitForFinish();
110 void waitForFinish();
92
111
93 class VariableControllerPrivate;
112 class VariableControllerPrivate;
94 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
113 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
95 };
114 };
96
115
97 #endif // SCIQLOP_VARIABLECONTROLLER_H
116 #endif // SCIQLOP_VARIABLECONTROLLER_H
Show file before | Show file after | Hide comments
@@ -1,13 +1,41
1 #include <Data/ScalarSeries.h>
1 #include <Data/ScalarSeries.h>
2
2
3 ScalarSeries::ScalarSeries(QVector<double> xAxisData, QVector<double> valuesData,
3 ScalarSeries::ScalarSeries(QVector<double> xAxisData, QVector<double> valuesData,
4 const Unit &xAxisUnit, const Unit &valuesUnit)
4 const Unit &xAxisUnit, const Unit &valuesUnit)
5 : DataSeries{std::make_shared<ArrayData<1> >(std::move(xAxisData)), xAxisUnit,
5 : DataSeries{std::make_shared<ArrayData<1> >(std::move(xAxisData)), xAxisUnit,
6 std::make_shared<ArrayData<1> >(std::move(valuesData)), valuesUnit}
6 std::make_shared<ArrayData<1> >(std::move(valuesData)), valuesUnit}
7 {
7 {
8 }
8 }
9
9
10 std::unique_ptr<IDataSeries> ScalarSeries::clone() const
10 std::unique_ptr<IDataSeries> ScalarSeries::clone() const
11 {
11 {
12 return std::make_unique<ScalarSeries>(*this);
12 return std::make_unique<ScalarSeries>(*this);
13 }
13 }
14
15 std::shared_ptr<IDataSeries> ScalarSeries::subData(const SqpRange &range)
16 {
17 auto subXAxisData = QVector<double>();
18 auto subValuesData = QVector<double>();
19 this->lockRead();
20 {
21 const auto &currentXData = this->xAxisData()->cdata();
22 const auto &currentValuesData = this->valuesData()->cdata();
23
24 auto xDataBegin = currentXData.cbegin();
25 auto xDataEnd = currentXData.cend();
26
27 auto lowerIt = std::lower_bound(xDataBegin, xDataEnd, range.m_TStart);
28 auto upperIt = std::upper_bound(xDataBegin, xDataEnd, range.m_TEnd);
29 auto distance = std::distance(xDataBegin, lowerIt);
30
31 auto valuesDataIt = currentValuesData.cbegin() + distance;
32 for (auto xAxisDataIt = lowerIt; xAxisDataIt != upperIt; ++xAxisDataIt, ++valuesDataIt) {
33 subXAxisData.append(*xAxisDataIt);
34 subValuesData.append(*valuesDataIt);
35 }
36 }
37 this->unlock();
38
39 return std::make_shared<ScalarSeries>(subXAxisData, subValuesData, this->xAxisUnit(),
40 this->valuesUnit());
41 }
Show file before | Show file after | Hide comments
@@ -1,133 +1,134
1 #include "Network/NetworkController.h"
1 #include "Network/NetworkController.h"
2
2
3 #include <QMutex>
3 #include <QMutex>
4 #include <QNetworkAccessManager>
4 #include <QNetworkAccessManager>
5 #include <QNetworkReply>
5 #include <QNetworkReply>
6 #include <QNetworkRequest>
6 #include <QNetworkRequest>
7 #include <QReadWriteLock>
7 #include <QReadWriteLock>
8 #include <QThread>
8 #include <QThread>
9
9
10 #include <unordered_map>
10 #include <unordered_map>
11
11
12 Q_LOGGING_CATEGORY(LOG_NetworkController, "NetworkController")
12 Q_LOGGING_CATEGORY(LOG_NetworkController, "NetworkController")
13
13
14 struct NetworkController::NetworkControllerPrivate {
14 struct NetworkController::NetworkControllerPrivate {
15 explicit NetworkControllerPrivate(NetworkController *parent) : m_WorkingMutex{} {}
15 explicit NetworkControllerPrivate(NetworkController *parent) : m_WorkingMutex{} {}
16
17 void lockRead() { m_Lock.lockForRead(); }
18 void lockWrite() { m_Lock.lockForWrite(); }
19 void unlock() { m_Lock.unlock(); }
20
16 QMutex m_WorkingMutex;
21 QMutex m_WorkingMutex;
17
22
18 QReadWriteLock m_Lock;
23 QReadWriteLock m_Lock;
19 std::unordered_map<QNetworkReply *, QUuid> m_NetworkReplyToVariableId;
24 std::unordered_map<QNetworkReply *, QUuid> m_NetworkReplyToVariableId;
20 std::unique_ptr<QNetworkAccessManager> m_AccessManager{nullptr};
25 std::unique_ptr<QNetworkAccessManager> m_AccessManager{nullptr};
21
22 void lockRead() { m_Lock.lockForRead(); }
23 void lockWrite() { m_Lock.lockForWrite(); }
24 void unlock() { m_Lock.unlock(); }
25 };
26 };
26
27
27 NetworkController::NetworkController(QObject *parent)
28 NetworkController::NetworkController(QObject *parent)
28 : QObject(parent), impl{spimpl::make_unique_impl<NetworkControllerPrivate>(this)}
29 : QObject(parent), impl{spimpl::make_unique_impl<NetworkControllerPrivate>(this)}
29 {
30 {
30 }
31 }
31
32
32 void NetworkController::onProcessRequested(const QNetworkRequest &request, QUuid identifier,
33 void NetworkController::onProcessRequested(const QNetworkRequest &request, QUuid identifier,
33 std::function<void(QNetworkReply *, QUuid)> callback)
34 std::function<void(QNetworkReply *, QUuid)> callback)
34 {
35 {
35 qCDebug(LOG_NetworkController()) << tr("NetworkController registered")
36 qCDebug(LOG_NetworkController()) << tr("NetworkController registered")
36 << QThread::currentThread()->objectName();
37 << QThread::currentThread()->objectName();
37 auto reply = impl->m_AccessManager->get(request);
38 auto reply = impl->m_AccessManager->get(request);
38
39
39 // Store the couple reply id
40 // Store the couple reply id
40 impl->lockWrite();
41 impl->lockWrite();
41 impl->m_NetworkReplyToVariableId[reply] = identifier;
42 impl->m_NetworkReplyToVariableId[reply] = identifier;
42 impl->unlock();
43 impl->unlock();
43
44
44 auto onReplyFinished = [reply, this, identifier, callback]() {
45 auto onReplyFinished = [reply, this, identifier, callback]() {
45
46
46 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished")
47 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished")
47 << QThread::currentThread() << reply;
48 << QThread::currentThread() << reply;
48 impl->lockRead();
49 impl->lockRead();
49 auto it = impl->m_NetworkReplyToVariableId.find(reply);
50 auto it = impl->m_NetworkReplyToVariableId.find(reply);
50 impl->unlock();
51 impl->unlock();
51 if (it != impl->m_NetworkReplyToVariableId.cend()) {
52 if (it != impl->m_NetworkReplyToVariableId.cend()) {
52 impl->lockWrite();
53 impl->lockWrite();
53 impl->m_NetworkReplyToVariableId.erase(reply);
54 impl->m_NetworkReplyToVariableId.erase(reply);
54 impl->unlock();
55 impl->unlock();
55 // Deletes reply
56 // Deletes reply
56 callback(reply, identifier);
57 callback(reply, identifier);
57 reply->deleteLater();
58 reply->deleteLater();
58
59
59 emit this->replyDownloadProgress(identifier, 0);
60 emit this->replyDownloadProgress(identifier, 0);
60 }
61 }
61
62
62 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished END")
63 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished END")
63 << QThread::currentThread() << reply;
64 << QThread::currentThread() << reply;
64 };
65 };
65
66
66 auto onReplyProgress = [reply, this](qint64 bytesRead, qint64 totalBytes) {
67 auto onReplyProgress = [reply, this](qint64 bytesRead, qint64 totalBytes) {
67
68
68 double progress = (bytesRead * 100.0) / totalBytes;
69 double progress = (bytesRead * 100.0) / totalBytes;
69 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress") << progress
70 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress") << progress
70 << QThread::currentThread() << reply;
71 << QThread::currentThread() << reply;
71 impl->lockRead();
72 impl->lockRead();
72 auto it = impl->m_NetworkReplyToVariableId.find(reply);
73 auto it = impl->m_NetworkReplyToVariableId.find(reply);
73 impl->unlock();
74 impl->unlock();
74 if (it != impl->m_NetworkReplyToVariableId.cend()) {
75 if (it != impl->m_NetworkReplyToVariableId.cend()) {
75 emit this->replyDownloadProgress(it->second, progress);
76 emit this->replyDownloadProgress(it->second, progress);
76 }
77 }
77 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress END")
78 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress END")
78 << QThread::currentThread() << reply;
79 << QThread::currentThread() << reply;
79 };
80 };
80
81
81
82
82 connect(reply, &QNetworkReply::finished, this, onReplyFinished);
83 connect(reply, &QNetworkReply::finished, this, onReplyFinished);
83 connect(reply, &QNetworkReply::downloadProgress, this, onReplyProgress);
84 connect(reply, &QNetworkReply::downloadProgress, this, onReplyProgress);
84 qCDebug(LOG_NetworkController()) << tr("NetworkController registered END")
85 qCDebug(LOG_NetworkController()) << tr("NetworkController registered END")
85 << QThread::currentThread()->objectName() << reply;
86 << QThread::currentThread()->objectName() << reply;
86 }
87 }
87
88
88 void NetworkController::initialize()
89 void NetworkController::initialize()
89 {
90 {
90 qCDebug(LOG_NetworkController()) << tr("NetworkController init") << QThread::currentThread();
91 qCDebug(LOG_NetworkController()) << tr("NetworkController init") << QThread::currentThread();
91 impl->m_WorkingMutex.lock();
92 impl->m_WorkingMutex.lock();
92 impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
93 impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
93
94
94
95
95 auto onReplyErrors = [this](QNetworkReply *reply, const QList<QSslError> &errors) {
96 auto onReplyErrors = [this](QNetworkReply *reply, const QList<QSslError> &errors) {
96
97
97 qCCritical(LOG_NetworkController()) << tr("NetworkAcessManager errors: ") << errors;
98 qCCritical(LOG_NetworkController()) << tr("NetworkAcessManager errors: ") << errors;
98
99
99 };
100 };
100
101
101
102
102 connect(impl->m_AccessManager.get(), &QNetworkAccessManager::sslErrors, this, onReplyErrors);
103 connect(impl->m_AccessManager.get(), &QNetworkAccessManager::sslErrors, this, onReplyErrors);
103
104
104 qCDebug(LOG_NetworkController()) << tr("NetworkController init END");
105 qCDebug(LOG_NetworkController()) << tr("NetworkController init END");
105 }
106 }
106
107
107 void NetworkController::finalize()
108 void NetworkController::finalize()
108 {
109 {
109 impl->m_WorkingMutex.unlock();
110 impl->m_WorkingMutex.unlock();
110 }
111 }
111
112
112 void NetworkController::onReplyCanceled(QUuid identifier)
113 void NetworkController::onReplyCanceled(QUuid identifier)
113 {
114 {
114 auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
115 auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
115 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled")
116 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled")
116 << QThread::currentThread();
117 << QThread::currentThread();
117
118
118
119
119 impl->lockRead();
120 impl->lockRead();
120 auto end = impl->m_NetworkReplyToVariableId.cend();
121 auto end = impl->m_NetworkReplyToVariableId.cend();
121 auto it = std::find_if(impl->m_NetworkReplyToVariableId.cbegin(), end, findReply);
122 auto it = std::find_if(impl->m_NetworkReplyToVariableId.cbegin(), end, findReply);
122 impl->unlock();
123 impl->unlock();
123 if (it != end) {
124 if (it != end) {
124 it->first->abort();
125 it->first->abort();
125 }
126 }
126 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled END")
127 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled END")
127 << QThread::currentThread();
128 << QThread::currentThread();
128 }
129 }
129
130
130 void NetworkController::waitForFinish()
131 void NetworkController::waitForFinish()
131 {
132 {
132 QMutexLocker locker{&impl->m_WorkingMutex};
133 QMutexLocker locker{&impl->m_WorkingMutex};
133 }
134 }
Show file before | Show file after | Hide comments
@@ -1,26 +1,225
1 #include "Variable/VariableAcquisitionWorker.h"
1 #include "Variable/VariableAcquisitionWorker.h"
2
2
3 #include "Variable/Variable.h"
3 #include "Variable/Variable.h"
4
5 #include <Data/AcquisitionRequest.h>
6 #include <Data/SqpRange.h>
7
4 #include <unordered_map>
8 #include <unordered_map>
9 #include <utility>
5
10
11 #include <QMutex>
12 #include <QReadWriteLock>
6 #include <QThread>
13 #include <QThread>
14
7 Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")
15 Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")
8
16
9 struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
17 struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
10
18
11 std::unordered_map<std::shared_ptr<Variable>, QVector<SqpRange> >
19 explicit VariableAcquisitionWorkerPrivate() : m_Lock{QReadWriteLock::Recursive} {}
12 m_VariableToSqpDateTimeListMap;
20
21 void lockRead() { m_Lock.lockForRead(); }
22 void lockWrite() { m_Lock.lockForWrite(); }
23 void unlock() { m_Lock.unlock(); }
24
25 void removeVariableRequest(QUuid vIdentifier);
26
27 QMutex m_WorkingMutex;
28 QReadWriteLock m_Lock;
29
30 std::map<QUuid, QVector<AcquisitionDataPacket> > m_AcqIdentifierToAcqDataPacketVectorMap;
31 std::map<QUuid, AcquisitionRequest> m_AcqIdentifierToAcqRequestMap;
32 std::map<QUuid, std::pair<QUuid, QUuid> > m_VIdentifierToCurrrentAcqIdNextIdPairMap;
13 };
33 };
14
34
15
35
16 VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
36 VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
17 : QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>()}
37 : QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>()}
18 {
38 {
19 }
39 }
20
40
21 void VariableAcquisitionWorker::pushVariableRequest(QUuid vIdentifier, SqpRange rangeRequest,
41 VariableAcquisitionWorker::~VariableAcquisitionWorker()
42 {
43 qCInfo(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker destruction")
44 << QThread::currentThread();
45 this->waitForFinish();
46 }
47
48
49 void VariableAcquisitionWorker::pushVariableRequest(QUuid vIdentifier, SqpRange rangeRequested,
22 SqpRange cacheRangeRequested,
50 SqpRange cacheRangeRequested,
23 DataProviderParameters parameters,
51 DataProviderParameters parameters,
24 IDataProvider *provider)
52 std::shared_ptr<IDataProvider> provider)
53 {
54 qCDebug(LOG_VariableAcquisitionWorker())
55 << tr("TORM VariableAcquisitionWorker::pushVariableRequest ") << cacheRangeRequested;
56
57 // Request creation
58 auto acqRequest = AcquisitionRequest{};
59 acqRequest.m_vIdentifier = vIdentifier;
60 acqRequest.m_DataProviderParameters = parameters;
61 acqRequest.m_RangeRequested = rangeRequested;
62 acqRequest.m_CacheRangeRequested = cacheRangeRequested;
63 acqRequest.m_Size = parameters.m_Times.size();
64 acqRequest.m_Provider = provider;
65
66 // Register request
67 impl->lockWrite();
68 impl->m_AcqIdentifierToAcqRequestMap.insert(
69 std::make_pair(acqRequest.m_AcqIdentifier, acqRequest));
70
71 auto it = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
72 if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
73 // A current request already exists, we can replace the next one
74 it->second.second = acqRequest.m_AcqIdentifier;
75 impl->unlock();
76 }
77 else {
78 // First request for the variable, it must be stored and executed
79 impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.insert(
80 std::make_pair(vIdentifier, std::make_pair(acqRequest.m_AcqIdentifier, QUuid())));
81 impl->unlock();
82
83 QMetaObject::invokeMethod(this, "onExecuteRequest", Qt::QueuedConnection,
84 Q_ARG(QUuid, acqRequest.m_AcqIdentifier));
85 }
86 }
87
88 void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
89 {
90 // TODO
91 }
92
93 void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
94 double progress)
95 {
96 // TODO
97 }
98
99 void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
100 std::shared_ptr<IDataSeries> dataSeries,
101 SqpRange dataRangeAcquired)
25 {
102 {
103 qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableDataAcquired on range ")
104 << acqIdentifier << dataRangeAcquired;
105 impl->lockWrite();
106 auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
107 if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
108 // Store the result
109 auto dataPacket = AcquisitionDataPacket{};
110 dataPacket.m_Range = dataRangeAcquired;
111 dataPacket.m_DateSeries = dataSeries;
112
113 auto aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
114 if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
115 // A current request result already exists, we can update it
116 aIdToADPVit->second.push_back(dataPacket);
117 }
118 else {
119 // First request result for the variable, it must be stored
120 impl->m_AcqIdentifierToAcqDataPacketVectorMap.insert(
121 std::make_pair(acqIdentifier, QVector<AcquisitionDataPacket>() << dataPacket));
122 }
123
124
125 // Decrement the counter of the request
126 auto &acqRequest = aIdToARit->second;
127 acqRequest.m_Size = acqRequest.m_Size - 1;
128
129 // if the counter is 0, we can return data then run the next request if it exists and
130 // removed the finished request
131 if (acqRequest.m_Size == 0) {
132 // Return the data
133 aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
134 if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
135 emit dataProvided(acqRequest.m_vIdentifier, acqRequest.m_RangeRequested,
136 acqRequest.m_CacheRangeRequested, aIdToADPVit->second);
137 }
138
139 // Execute the next one
140 auto it
141 = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(acqRequest.m_vIdentifier);
142
143 if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
144 if (it->second.second.isNull()) {
note
perrinel
Comment #1882
Edit
Delete
|

If we do so, we create a unnecessary intermediate variable. Something like : auto & varNextRequest = it->second if(varNextRequest.second.isNull()) { We gain a little bit in understanding but we lose in memory. I prefer clarify it in the comment : // There is no next request, we can remove the variable request This comment has been added later
145 // There is no next request, we can remove the varibale request
146 impl->removeVariableRequest(acqRequest.m_vIdentifier);
147 }
148 else {
149 auto acqIdentifierToRemove = it->second.first;
150 // Move the next request to the current request
151 it->second.first = it->second.second;
152 it->second.second = QUuid();
153 // Remove AcquisitionRequest and results;
154 impl->m_AcqIdentifierToAcqRequestMap.erase(acqIdentifierToRemove);
155 impl->m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqIdentifierToRemove);
156 // Execute the current request
157 QMetaObject::invokeMethod(this, "onExecuteRequest", Qt::QueuedConnection,
158 Q_ARG(QUuid, it->second.first));
159 }
160 }
161 else {
162 qCCritical(LOG_VariableAcquisitionWorker())
163 << tr("Impossible to execute the acquisition on an unfound variable ");
164 }
165 }
166 }
167 else {
168 qCCritical(LOG_VariableAcquisitionWorker())
169 << tr("Impossible to retrieve AcquisitionRequest for the incoming data");
170 }
171 impl->unlock();
172 }
173
174 void VariableAcquisitionWorker::onExecuteRequest(QUuid acqIdentifier)
175 {
176 qCDebug(LOG_VariableAcquisitionWorker()) << tr("onExecuteRequest") << QThread::currentThread();
177 impl->lockRead();
178 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
179 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
180 auto request = it->second;
181 impl->unlock();
182 request.m_Provider->requestDataLoading(acqIdentifier, request.m_DataProviderParameters);
183 }
184 else {
185 impl->unlock();
186 // TODO log no acqIdentifier recognized
187 }
188 }
189
190 void VariableAcquisitionWorker::initialize()
191 {
192 qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init")
193 << QThread::currentThread();
194 impl->m_WorkingMutex.lock();
195 qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init END");
196 }
197
198 void VariableAcquisitionWorker::finalize()
199 {
200 impl->m_WorkingMutex.unlock();
201 }
202
203 void VariableAcquisitionWorker::waitForFinish()
204 {
205 QMutexLocker locker{&impl->m_WorkingMutex};
206 }
207
208 void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::removeVariableRequest(
209 QUuid vIdentifier)
210 {
211 lockWrite();
212 auto it = m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
213
214 if (it != m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
215 // A current request already exists, we can replace the next one
216
217 m_AcqIdentifierToAcqRequestMap.erase(it->second.first);
218 m_AcqIdentifierToAcqDataPacketVectorMap.erase(it->second.first);
219
220 m_AcqIdentifierToAcqRequestMap.erase(it->second.second);
221 m_AcqIdentifierToAcqDataPacketVectorMap.erase(it->second.second);
222 }
223 m_VIdentifierToCurrrentAcqIdNextIdPairMap.erase(vIdentifier);
224 unlock();
26 }
225 }
Show file before | Show file after | Hide comments
@@ -1,276 +1,508
1 #include <Variable/Variable.h>
1 #include <Variable/Variable.h>
2 #include <Variable/VariableAcquisitionWorker.h>
2 #include <Variable/VariableCacheController.h>
3 #include <Variable/VariableCacheController.h>
4 #include <Variable/VariableCacheStrategy.h>
3 #include <Variable/VariableController.h>
5 #include <Variable/VariableController.h>
4 #include <Variable/VariableModel.h>
6 #include <Variable/VariableModel.h>
7 #include <Variable/VariableSynchronizationGroup.h>
5
8
6 #include <Data/DataProviderParameters.h>
9 #include <Data/DataProviderParameters.h>
7 #include <Data/IDataProvider.h>
10 #include <Data/IDataProvider.h>
8 #include <Data/IDataSeries.h>
11 #include <Data/IDataSeries.h>
9 #include <Time/TimeController.h>
12 #include <Time/TimeController.h>
10
13
11 #include <QMutex>
14 #include <QMutex>
12 #include <QThread>
15 #include <QThread>
13 #include <QUuid>
16 #include <QUuid>
14 #include <QtCore/QItemSelectionModel>
17 #include <QtCore/QItemSelectionModel>
15
18
19 #include <set>
16 #include <unordered_map>
20 #include <unordered_map>
17
21
18 Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
22 Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
19
23
24 namespace {
25
26 SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &grapheRange,
note
perrinel
Comment #1883
Edit
Delete
|

ok
27 const SqpRange &oldGraphRange)
28 {
29 auto zoomType = VariableController::getZoomType(grapheRange, oldGraphRange);
30
31 auto varRangeRequested = varRange;
32 switch (zoomType) {
33 case AcquisitionZoomType::ZoomIn: {
34 auto deltaLeft = grapheRange.m_TStart - oldGraphRange.m_TStart;
35 auto deltaRight = oldGraphRange.m_TEnd - grapheRange.m_TEnd;
36 varRangeRequested.m_TStart += deltaLeft;
37 varRangeRequested.m_TEnd -= deltaRight;
38 break;
39 }
40
41 case AcquisitionZoomType::ZoomOut: {
42 auto deltaLeft = oldGraphRange.m_TStart - grapheRange.m_TStart;
43 auto deltaRight = grapheRange.m_TEnd - oldGraphRange.m_TEnd;
44 varRangeRequested.m_TStart -= deltaLeft;
45 varRangeRequested.m_TEnd += deltaRight;
46 break;
47 }
48 case AcquisitionZoomType::PanRight: {
49 auto deltaRight = grapheRange.m_TEnd - oldGraphRange.m_TEnd;
50 varRangeRequested.m_TStart += deltaRight;
51 varRangeRequested.m_TEnd += deltaRight;
52 break;
53 }
54 case AcquisitionZoomType::PanLeft: {
55 auto deltaLeft = oldGraphRange.m_TStart - grapheRange.m_TStart;
56 varRangeRequested.m_TStart -= deltaLeft;
57 varRangeRequested.m_TEnd -= deltaLeft;
58 break;
59 }
60 case AcquisitionZoomType::Unknown: {
61 qCCritical(LOG_VariableController())
62 << VariableController::tr("Impossible to synchronize: zoom type unknown");
63 break;
64 }
65 default:
66 qCCritical(LOG_VariableController()) << VariableController::tr(
67 "Impossible to synchronize: zoom type not take into account");
68 // No action
69 break;
70 }
71
72 return varRangeRequested;
73 }
74 }
75
20 struct VariableController::VariableControllerPrivate {
76 struct VariableController::VariableControllerPrivate {
21 explicit VariableControllerPrivate(VariableController *parent)
77 explicit VariableControllerPrivate(VariableController *parent)
22 : m_WorkingMutex{},
78 : m_WorkingMutex{},
23 m_VariableModel{new VariableModel{parent}},
79 m_VariableModel{new VariableModel{parent}},
24 m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
80 m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
25 m_VariableCacheController{std::make_unique<VariableCacheController>()}
81 m_VariableCacheController{std::make_unique<VariableCacheController>()},
82 m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
83 m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()}
84 {
85
86 m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);
87 m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");
88 }
89
90
91 virtual ~VariableControllerPrivate()
26 {
92 {
93 qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");
94 m_VariableAcquisitionWorkerThread.quit();
95 m_VariableAcquisitionWorkerThread.wait();
27 }
96 }
28
97
98
99 void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested);
100
29 QVector<SqpRange> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
101 QVector<SqpRange> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
30 const SqpRange &dateTime);
102 const SqpRange &dateTime);
31
103
104 std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
105 std::shared_ptr<IDataSeries>
106 retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);
107
108 void registerProvider(std::shared_ptr<IDataProvider> provider);
109
32 QMutex m_WorkingMutex;
110 QMutex m_WorkingMutex;
33 /// Variable model. The VariableController has the ownership
111 /// Variable model. The VariableController has the ownership
34 VariableModel *m_VariableModel;
112 VariableModel *m_VariableModel;
35 QItemSelectionModel *m_VariableSelectionModel;
113 QItemSelectionModel *m_VariableSelectionModel;
36
114
37
115
38 TimeController *m_TimeController{nullptr};
116 TimeController *m_TimeController{nullptr};
39 std::unique_ptr<VariableCacheController> m_VariableCacheController;
117 std::unique_ptr<VariableCacheController> m_VariableCacheController;
118 std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
119 std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
120 QThread m_VariableAcquisitionWorkerThread;
40
121
41 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
122 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
42 m_VariableToProviderMap;
123 m_VariableToProviderMap;
43 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
124 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
125 std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >
126 m_GroupIdToVariableSynchronizationGroupMap;
127 std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
128 std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
44 };
129 };
45
130
131
46 VariableController::VariableController(QObject *parent)
132 VariableController::VariableController(QObject *parent)
47 : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
133 : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
48 {
134 {
49 qCDebug(LOG_VariableController()) << tr("VariableController construction")
135 qCDebug(LOG_VariableController()) << tr("VariableController construction")
50 << QThread::currentThread();
136 << QThread::currentThread();
51
137
52 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
138 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
53 &VariableController::onAbortProgressRequested);
139 &VariableController::onAbortProgressRequested);
140
141 connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,
142 &VariableController::onDataProvided);
143 connect(impl->m_VariableAcquisitionWorker.get(),
144 &VariableAcquisitionWorker::variableRequestInProgress, this,
145 &VariableController::onVariableRetrieveDataInProgress);
146
147 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,
148 impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);
149 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,
150 impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::finalize);
151
152
153 impl->m_VariableAcquisitionWorkerThread.start();
54 }
154 }
55
155
56 VariableController::~VariableController()
156 VariableController::~VariableController()
57 {
157 {
58 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
158 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
59 << QThread::currentThread();
159 << QThread::currentThread();
60 this->waitForFinish();
160 this->waitForFinish();
61 }
161 }
62
162
63 VariableModel *VariableController::variableModel() noexcept
163 VariableModel *VariableController::variableModel() noexcept
64 {
164 {
65 return impl->m_VariableModel;
165 return impl->m_VariableModel;
66 }
166 }
67
167
68 QItemSelectionModel *VariableController::variableSelectionModel() noexcept
168 QItemSelectionModel *VariableController::variableSelectionModel() noexcept
69 {
169 {
70 return impl->m_VariableSelectionModel;
170 return impl->m_VariableSelectionModel;
71 }
171 }
72
172
73 void VariableController::setTimeController(TimeController *timeController) noexcept
173 void VariableController::setTimeController(TimeController *timeController) noexcept
74 {
174 {
75 impl->m_TimeController = timeController;
175 impl->m_TimeController = timeController;
76 }
176 }
77
177
78 void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
178 void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
79 {
179 {
80 if (!variable) {
180 if (!variable) {
81 qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
181 qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
82 return;
182 return;
83 }
183 }
84
184
85 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
185 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
86 // make some treatments before the deletion
186 // make some treatments before the deletion
87 emit variableAboutToBeDeleted(variable);
187 emit variableAboutToBeDeleted(variable);
88
188
89 // Deletes identifier
189 // Deletes identifier
90 impl->m_VariableToIdentifierMap.erase(variable);
190 impl->m_VariableToIdentifierMap.erase(variable);
91
191
92 // Deletes provider
192 // Deletes provider
93 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
193 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
94 qCDebug(LOG_VariableController())
194 qCDebug(LOG_VariableController())
95 << tr("Number of providers deleted for variable %1: %2")
195 << tr("Number of providers deleted for variable %1: %2")
96 .arg(variable->name(), QString::number(nbProvidersDeleted));
196 .arg(variable->name(), QString::number(nbProvidersDeleted));
97
197
98 // Clears cache
198 // Clears cache
99 impl->m_VariableCacheController->clear(variable);
199 impl->m_VariableCacheController->clear(variable);
100
200
101 // Deletes from model
201 // Deletes from model
102 impl->m_VariableModel->deleteVariable(variable);
202 impl->m_VariableModel->deleteVariable(variable);
103 }
203 }
104
204
105 void VariableController::deleteVariables(
205 void VariableController::deleteVariables(
106 const QVector<std::shared_ptr<Variable> > &variables) noexcept
206 const QVector<std::shared_ptr<Variable> > &variables) noexcept
107 {
207 {
108 for (auto variable : qAsConst(variables)) {
208 for (auto variable : qAsConst(variables)) {
109 deleteVariable(variable);
209 deleteVariable(variable);
110 }
210 }
111 }
211 }
112
212
113 void VariableController::abortProgress(std::shared_ptr<Variable> variable)
213 void VariableController::abortProgress(std::shared_ptr<Variable> variable)
114 {
214 {
115 }
215 }
116
216
117 void VariableController::createVariable(const QString &name, const QVariantHash &metadata,
217 void VariableController::createVariable(const QString &name, const QVariantHash &metadata,
118 std::shared_ptr<IDataProvider> provider) noexcept
218 std::shared_ptr<IDataProvider> provider) noexcept
119 {
219 {
120
220
121 if (!impl->m_TimeController) {
221 if (!impl->m_TimeController) {
122 qCCritical(LOG_VariableController())
222 qCCritical(LOG_VariableController())
123 << tr("Impossible to create variable: The time controller is null");
223 << tr("Impossible to create variable: The time controller is null");
124 return;
224 return;
125 }
225 }
126
226
127 auto dateTime = impl->m_TimeController->dateTime();
227 auto range = impl->m_TimeController->dateTime();
128
228
129 if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime, metadata)) {
229 if (auto newVariable = impl->m_VariableModel->createVariable(name, range, metadata)) {
130 auto identifier = QUuid::createUuid();
230 auto identifier = QUuid::createUuid();
131
231
132 // store the provider
232 // store the provider
233 impl->registerProvider(provider);
234
235 // Associate the provider
133 impl->m_VariableToProviderMap[newVariable] = provider;
236 impl->m_VariableToProviderMap[newVariable] = provider;
134 impl->m_VariableToIdentifierMap[newVariable] = identifier;
237 impl->m_VariableToIdentifierMap[newVariable] = identifier;
135
238
136 auto addDateTimeAcquired = [ this, varW = std::weak_ptr<Variable>{newVariable} ](
137 QUuid identifier, auto dataSeriesAcquired, auto dateTimeToPutInCache)
138 {
139 if (auto variable = varW.lock()) {
140 auto varIdentifier = impl->m_VariableToIdentifierMap.at(variable);
141 if (varIdentifier == identifier) {
142 impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
143 variable->setDataSeries(dataSeriesAcquired);
144 emit variable->updated();
145 }
146 }
147 };
148
239
149 connect(provider.get(), &IDataProvider::dataProvided, addDateTimeAcquired);
240 impl->processRequest(newVariable, range);
150 connect(provider.get(), &IDataProvider::dataProvidedProgress, this,
151 &VariableController::onVariableRetrieveDataInProgress);
152 this->onRequestDataLoading(newVariable, dateTime);
153 }
241 }
154 }
242 }
155
243
156 void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
244 void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
157 {
245 {
246 // TODO check synchronisation
158 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
247 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
159 << QThread::currentThread()->objectName();
248 << QThread::currentThread()->objectName();
160 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
249 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
161
250
162 for (const auto &selectedRow : qAsConst(selectedRows)) {
251 for (const auto &selectedRow : qAsConst(selectedRows)) {
163 if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
252 if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
164 selectedVariable->setDateTime(dateTime);
253 selectedVariable->setRange(dateTime);
165 this->onRequestDataLoading(selectedVariable, dateTime);
254 impl->processRequest(selectedVariable, dateTime);
166
255
167 // notify that rescale operation has to be done
256 // notify that rescale operation has to be done
168 emit rangeChanged(selectedVariable, dateTime);
257 emit rangeChanged(selectedVariable, dateTime);
169 }
258 }
170 }
259 }
171 }
260 }
172
261
173 void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
262 void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
263 const SqpRange &cacheRangeRequested,
264 QVector<AcquisitionDataPacket> dataAcquired)
174 {
265 {
175 auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
266 qCCritical(LOG_VariableController()) << tr("onDataProvided") << dataAcquired.isEmpty();
note
perrinel
Comment #1884
Edit
Delete
|

The comment has been remove later.
267
268 auto var = impl->findVariable(vIdentifier);
269 if (var != nullptr) {
note
perrinel
Comment #1885
Edit
Delete
|

ok
270 var->setRange(rangeRequested);
271 var->setCacheRange(cacheRangeRequested);
272 qCCritical(LOG_VariableController()) << tr("1: onDataProvided") << rangeRequested;
273 qCCritical(LOG_VariableController()) << tr("2: onDataProvided") << cacheRangeRequested;
274
275 auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
276 qCCritical(LOG_VariableController()) << tr("3: onDataProvided")
277 << retrievedDataSeries->range();
278 var->mergeDataSeries(retrievedDataSeries);
279 emit var->updated();
280 }
281 else {
282 qCCritical(LOG_VariableController()) << tr("Impossible to provide data to a null variable");
283 }
284 }
176
285
177 auto end = impl->m_VariableToIdentifierMap.cend();
286 void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
178 auto it = std::find_if(impl->m_VariableToIdentifierMap.cbegin(), end, findReply);
287 {
179 if (it != end) {
288 auto var = impl->findVariable(identifier);
180 impl->m_VariableModel->setDataProgress(it->first, progress);
289 if (var != nullptr) {
note
perrinel
Comment #1886
Edit
Delete
|

ok
290 impl->m_VariableModel->setDataProgress(var, progress);
291 }
292 else {
293 qCCritical(LOG_VariableController())
294 << tr("Impossible to notify progression of a null variable");
181 }
295 }
182 }
296 }
183
297
184 void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
298 void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
185 {
299 {
186 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"
300 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"
187 << QThread::currentThread()->objectName();
301 << QThread::currentThread()->objectName();
188
302
189 auto it = impl->m_VariableToIdentifierMap.find(variable);
303 auto it = impl->m_VariableToIdentifierMap.find(variable);
190 if (it != impl->m_VariableToIdentifierMap.cend()) {
304 if (it != impl->m_VariableToIdentifierMap.cend()) {
191 impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);
305 impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);
192 }
306 }
193 else {
307 else {
194 qCWarning(LOG_VariableController())
308 qCWarning(LOG_VariableController())
195 << tr("Aborting progression of inexistant variable detected !!!")
309 << tr("Aborting progression of inexistant variable detected !!!")
196 << QThread::currentThread()->objectName();
310 << QThread::currentThread()->objectName();
197 }
311 }
198 }
312 }
199
313
314 void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
315 {
316 auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
317 impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
318 std::make_pair(synchronizationGroupId, vSynchroGroup));
319 }
320
321 void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)
322 {
323 impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);
324 }
325
200
326
201 void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
327 void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
202 const SqpRange &dateTime)
328 const SqpRange &range, const SqpRange &oldRange,
329 bool synchronise)
203 {
330 {
331 // NOTE: oldRange isn't really necessary since oldRange == variable->range().
332
204 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
333 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
205 << QThread::currentThread()->objectName();
334 << QThread::currentThread()->objectName();
206 // we want to load data of the variable for the dateTime.
335 // we want to load data of the variable for the dateTime.
207 // First we check if the cache contains some of them.
336 // First we check if the cache contains some of them.
208 // For the other, we ask the provider to give them.
337 // For the other, we ask the provider to give them.
209 if (variable) {
210
338
211 auto dateTimeListNotInCache
339 foreach (auto var, variables) {
note
perrinel
Comment #1887
Edit
Delete
|

Right
212 = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
340 qCInfo(LOG_VariableController()) << "processRequest for" << var->name();
341 impl->processRequest(var, range);
342 }
213
343
214 if (!dateTimeListNotInCache.empty()) {
344 if (synchronise) {
215 // Ask the provider for each data on the dateTimeListNotInCache
345 // Get the group ids
216 auto identifier = impl->m_VariableToIdentifierMap.at(variable);
346 qCInfo(LOG_VariableController())
217 impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
347 << "VariableController::onRequestDataLoading for synchro var ENABLE";
218 identifier,
348 auto groupIds = std::set<QUuid>();
219 DataProviderParameters{std::move(dateTimeListNotInCache), variable->metadata()});
349 foreach (auto var, variables) {
note
perrinel
Comment #1888
Edit
Delete
|

ok
350 auto vToVIdit = impl->m_VariableToIdentifierMap.find(var);
351 if (vToVIdit != impl->m_VariableToIdentifierMap.cend()) {
note
perrinel
Comment #1890
Edit
Delete
|

Yes, I found the same and changed it for varToVarIdIt
352 auto vId = vToVIdit->second;
353
354 auto vIdToGIdit = impl->m_VariableIdGroupIdMap.find(vId);
355 if (vIdToGIdit != impl->m_VariableIdGroupIdMap.cend()) {
356 auto gId = vToVIdit->second;
357 if (groupIds.find(gId) == groupIds.cend()) {
358 groupIds.insert(gId);
359 }
360 }
361 }
220 }
362 }
221 else {
363
222 emit variable->updated();
364 // We assume here all group ids exist
365 foreach (auto gId, groupIds) {
366 auto vSynchronizationGroup = impl->m_GroupIdToVariableSynchronizationGroupMap.at(gId);
367 auto vSyncIds = vSynchronizationGroup->getIds();
368 for (auto vId : vSyncIds) {
369 auto var = impl->findVariable(vId);
370 if (var != nullptr) {
371 qCInfo(LOG_VariableController()) << "processRequest synchro for" << var->name();
372 auto vSyncRangeRequested
373 = computeSynchroRangeRequested(var->range(), range, oldRange);
374 impl->processRequest(var, vSyncRangeRequested);
375 }
376 else {
377 qCCritical(LOG_VariableController())
378 << tr("Impossible to synchronize a null variable");
379 }
380 }
223 }
381 }
224 }
382 }
225 else {
226 qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
227 }
228 }
383 }
229
384
230
385
231 void VariableController::initialize()
386 void VariableController::initialize()
232 {
387 {
233 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
388 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
234 impl->m_WorkingMutex.lock();
389 impl->m_WorkingMutex.lock();
235 qCDebug(LOG_VariableController()) << tr("VariableController init END");
390 qCDebug(LOG_VariableController()) << tr("VariableController init END");
236 }
391 }
237
392
238 void VariableController::finalize()
393 void VariableController::finalize()
239 {
394 {
240 impl->m_WorkingMutex.unlock();
395 impl->m_WorkingMutex.unlock();
241 }
396 }
242
397
243 void VariableController::waitForFinish()
398 void VariableController::waitForFinish()
244 {
399 {
245 QMutexLocker locker{&impl->m_WorkingMutex};
400 QMutexLocker locker{&impl->m_WorkingMutex};
246 }
401 }
247
402
403 AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
404 {
405 // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
406 auto zoomType = AcquisitionZoomType::Unknown;
407 if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
408 zoomType = AcquisitionZoomType::ZoomOut;
409 }
410 else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
411 zoomType = AcquisitionZoomType::PanRight;
412 }
413 else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
414 zoomType = AcquisitionZoomType::PanLeft;
415 }
416 else if (range.m_TStart > oldRange.m_TStart && oldRange.m_TEnd > range.m_TEnd) {
417 zoomType = AcquisitionZoomType::ZoomIn;
418 }
419 else {
420 qCCritical(LOG_VariableController()) << "getZoomType: Unknown type detected";
421 }
422 return zoomType;
423 }
248
424
249 QVector<SqpRange> VariableController::VariableControllerPrivate::provideNotInCacheDateTimeList(
425 void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
250 std::shared_ptr<Variable> variable, const SqpRange &dateTime)
426 const SqpRange &rangeRequested)
251 {
427 {
252 auto notInCache = QVector<SqpRange>{};
253
428
254 if (!variable->contains(dateTime)) {
429 auto varRangesRequested
255 auto vDateTime = variable->dateTime();
430 = m_VariableCacheStrategy->computeCacheRange(var->range(), rangeRequested);
256 if (dateTime.m_TEnd <= vDateTime.m_TStart || dateTime.m_TStart >= vDateTime.m_TEnd) {
431 auto notInCacheRangeList = var->provideNotInCacheRangeList(varRangesRequested.second);
257 notInCache << dateTime;
432
258 }
433 if (!notInCacheRangeList.empty()) {
259 else if (dateTime.m_TStart < vDateTime.m_TStart && dateTime.m_TEnd <= vDateTime.m_TEnd) {
434 // Display part of data which are already there
260 notInCache << SqpRange{dateTime.m_TStart, vDateTime.m_TStart};
435 // Ask the provider for each data on the dateTimeListNotInCache
261 }
436 auto identifier = m_VariableToIdentifierMap.at(var);
262 else if (dateTime.m_TStart < vDateTime.m_TStart && dateTime.m_TEnd > vDateTime.m_TEnd) {
437 auto varProvider = m_VariableToProviderMap.at(var);
263 notInCache << SqpRange{dateTime.m_TStart, vDateTime.m_TStart}
438 if (varProvider != nullptr) {
264 << SqpRange{vDateTime.m_TEnd, dateTime.m_TStart};
439 m_VariableAcquisitionWorker->pushVariableRequest(
265 }
440 identifier, varRangesRequested.first, varRangesRequested.second,
266 else if (dateTime.m_TStart < vDateTime.m_TEnd) {
441 DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
267 notInCache << SqpRange{vDateTime.m_TEnd, dateTime.m_TStart};
442 varProvider);
268 }
443 }
269 else {
444 else {
270 qCCritical(LOG_VariableController()) << tr("Detection of unknown case.")
445 qCCritical(LOG_VariableController())
271 << QThread::currentThread();
446 << "Impossible to provide data with a null provider";
272 }
447 }
273 }
448 }
449 else {
450 var->setRange(rangeRequested);
451 var->setCacheRange(varRangesRequested.second);
452 var->setDataSeries(var->dataSeries()->subData(varRangesRequested.second));
453 emit var->updated();
454 }
455 }
456
457 std::shared_ptr<Variable>
458 VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
459 {
460 std::shared_ptr<Variable> var;
461 auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
462
463 auto end = m_VariableToIdentifierMap.cend();
464 auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
465 if (it != end) {
466 var = it->first;
467 }
468 else {
469 qCCritical(LOG_VariableController())
470 << tr("Impossible to find the variable with the identifier: ") << vIdentifier;
471 }
274
472
275 return notInCache;
473 return var;
474 }
475
476 std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
477 const QVector<AcquisitionDataPacket> acqDataPacketVector)
478 {
479 qCInfo(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
480 << acqDataPacketVector.size();
481 std::shared_ptr<IDataSeries> dataSeries;
482 if (!acqDataPacketVector.isEmpty()) {
483 dataSeries = acqDataPacketVector[0].m_DateSeries;
484 for (int i = 1; i < acqDataPacketVector.size(); ++i) {
485 dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
486 }
487 }
488
489 return dataSeries;
490 }
491
492 void VariableController::VariableControllerPrivate::registerProvider(
493 std::shared_ptr<IDataProvider> provider)
494 {
495 if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
496 qCInfo(LOG_VariableController()) << tr("Registering of a new provider")
497 << provider->objectName();
498 m_ProviderSet.insert(provider);
499 connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
500 &VariableAcquisitionWorker::onVariableDataAcquired);
501 connect(provider.get(), &IDataProvider::dataProvidedProgress,
502 m_VariableAcquisitionWorker.get(),
503 &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
504 }
505 else {
506 qCInfo(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
507 }
276 }
508 }
Show file before | Show file after | Hide comments
@@ -1,84 +1,80
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 /**
20 * Possible types of zoom operation
21 */
22 enum class VisualizationGraphWidgetZoomType { ZoomOut, ZoomIn, PanRight, PanLeft, Unknown };
23
24 namespace Ui {
19 namespace Ui {
25 class VisualizationGraphWidget;
20 class VisualizationGraphWidget;
26 } // namespace Ui
21 } // namespace Ui
27
22
28 class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
23 class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
29 Q_OBJECT
24 Q_OBJECT
30
25
31 public:
26 public:
32 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
27 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
33 virtual ~VisualizationGraphWidget();
28 virtual ~VisualizationGraphWidget();
34
29
35 void enableSynchronize(bool enable);
30 /// If acquisition isn't enable, requestDataLoading signal cannot be emit
31 void enableAcquisition(bool enable);
36
32
37 void addVariable(std::shared_ptr<Variable> variable);
33 void addVariable(std::shared_ptr<Variable> variable);
38 void addVariableUsingGraph(std::shared_ptr<Variable> variable);
34 void addVariableUsingGraph(std::shared_ptr<Variable> variable);
39 /// Removes a variable from the graph
35 /// Removes a variable from the graph
40 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
36 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
41
37
42 void setRange(std::shared_ptr<Variable> variable, const SqpRange &range);
38 void setRange(std::shared_ptr<Variable> variable, const SqpRange &range);
43 SqpRange graphRange() const noexcept;
39 SqpRange graphRange() const noexcept;
44 void setGraphRange(const SqpRange &range);
40 void setGraphRange(const SqpRange &range);
45
41
46 // IVisualizationWidget interface
42 // IVisualizationWidget interface
47 void accept(IVisualizationWidgetVisitor *visitor) override;
43 void accept(IVisualizationWidgetVisitor *visitor) override;
48 bool canDrop(const Variable &variable) const override;
44 bool canDrop(const Variable &variable) const override;
49 bool contains(const Variable &variable) const override;
45 bool contains(const Variable &variable) const override;
50 QString name() const override;
46 QString name() const override;
51
47
52
48
53 signals:
49 signals:
54 void requestDataLoading(std::shared_ptr<Variable> variable, const SqpRange &dateTime);
50 void synchronize(const SqpRange &range, const SqpRange &oldRange);
55 void synchronize(const SqpRange &dateTime, const SqpRange &oldDateTime,
51 void requestDataLoading(QVector<std::shared_ptr<Variable> > variable, const SqpRange &range,
56 VisualizationGraphWidgetZoomType zoomType);
52 const SqpRange &oldRange, bool synchronise);
57
53
58
54
59 private:
55 private:
60 Ui::VisualizationGraphWidget *ui;
56 Ui::VisualizationGraphWidget *ui;
61
57
62 class VisualizationGraphWidgetPrivate;
58 class VisualizationGraphWidgetPrivate;
63 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
59 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
64
60
65 private slots:
61 private slots:
66 /// Slot called when right clicking on the graph (displays a menu)
62 /// Slot called when right clicking on the graph (displays a menu)
67 void onGraphMenuRequested(const QPoint &pos) noexcept;
63 void onGraphMenuRequested(const QPoint &pos) noexcept;
68
64
69 /// Rescale the X axe to range parameter
65 /// Rescale the X axe to range parameter
70 void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
66 void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
71
67
72 /// Slot called when a mouse move was made
68 /// Slot called when a mouse move was made
73 void onMouseMove(QMouseEvent *event) noexcept;
69 void onMouseMove(QMouseEvent *event) noexcept;
74 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
70 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
75 void onMouseWheel(QWheelEvent *event) noexcept;
71 void onMouseWheel(QWheelEvent *event) noexcept;
76 /// Slot called when a mouse press was made, to activate the calibration of a graph
72 /// Slot called when a mouse press was made, to activate the calibration of a graph
77 void onMousePress(QMouseEvent *event) noexcept;
73 void onMousePress(QMouseEvent *event) noexcept;
78 /// Slot called when a mouse release was made, to deactivate the calibration of a graph
74 /// Slot called when a mouse release was made, to deactivate the calibration of a graph
79 void onMouseRelease(QMouseEvent *event) noexcept;
75 void onMouseRelease(QMouseEvent *event) noexcept;
80
76
81 void onDataCacheVariableUpdated();
77 void onDataCacheVariableUpdated();
82 };
78 };
83
79
84 #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
80 #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
Show file before | Show file after | Hide comments
@@ -1,45 +1,52
1 #ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
1 #ifndef SCIQLOP_VISUALIZATIONZONEWIDGET_H
2 #define SCIQLOP_VISUALIZATIONZONEWIDGET_H
2 #define SCIQLOP_VISUALIZATIONZONEWIDGET_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>
10
11 #include <Common/spimpl.h>
12
9 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationZoneWidget)
13 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationZoneWidget)
10
14
11 namespace Ui {
15 namespace Ui {
12 class VisualizationZoneWidget;
16 class VisualizationZoneWidget;
13 } // Ui
17 } // Ui
14
18
15 class Variable;
19 class Variable;
16 class VisualizationGraphWidget;
20 class VisualizationGraphWidget;
17
21
18 class VisualizationZoneWidget : public QWidget, public IVisualizationWidget {
22 class VisualizationZoneWidget : public QWidget, public IVisualizationWidget {
19 Q_OBJECT
23 Q_OBJECT
20
24
21 public:
25 public:
22 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
26 explicit VisualizationZoneWidget(const QString &name = {}, QWidget *parent = 0);
23 virtual ~VisualizationZoneWidget();
27 virtual ~VisualizationZoneWidget();
24
28
25 /// Add a graph widget
29 /// Add a graph widget
26 void addGraph(VisualizationGraphWidget *graphWidget);
30 void addGraph(VisualizationGraphWidget *graphWidget);
27
31
28 /**
32 /**
29 * Creates a graph using a variable. The variable will be displayed in the new graph.
33 * Creates a graph using a variable. The variable will be displayed in the new graph.
30 * @param variable the variable for which to create the graph
34 * @param variable the variable for which to create the graph
31 * @return the pointer to the created graph
35 * @return the pointer to the created graph
32 */
36 */
33 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
37 VisualizationGraphWidget *createGraph(std::shared_ptr<Variable> variable);
34
38
35 // IVisualizationWidget interface
39 // IVisualizationWidget interface
36 void accept(IVisualizationWidgetVisitor *visitor) override;
40 void accept(IVisualizationWidgetVisitor *visitor) override;
37 bool canDrop(const Variable &variable) const override;
41 bool canDrop(const Variable &variable) const override;
38 bool contains(const Variable &variable) const override;
42 bool contains(const Variable &variable) const override;
39 QString name() const override;
43 QString name() const override;
40
44
41 private:
45 private:
42 Ui::VisualizationZoneWidget *ui;
46 Ui::VisualizationZoneWidget *ui;
47
48 class VisualizationZoneWidgetPrivate;
49 spimpl::unique_impl_ptr<VisualizationZoneWidgetPrivate> impl;
43 };
50 };
44
51
45 #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H
52 #endif // SCIQLOP_VISUALIZATIONZONEWIDGET_H
Show file before | Show file after | Hide comments
@@ -1,151 +1,151
1 #include "SqpApplication.h"
1 #include "SqpApplication.h"
2
2
3 #include <Data/IDataProvider.h>
3 #include <Data/IDataProvider.h>
4 #include <DataSource/DataSourceController.h>
4 #include <DataSource/DataSourceController.h>
5 #include <Network/NetworkController.h>
5 #include <Network/NetworkController.h>
6 #include <QThread>
6 #include <QThread>
7 #include <Time/TimeController.h>
7 #include <Time/TimeController.h>
8 #include <Variable/Variable.h>
8 #include <Variable/Variable.h>
9 #include <Variable/VariableController.h>
9 #include <Variable/VariableController.h>
10 #include <Visualization/VisualizationController.h>
10 #include <Visualization/VisualizationController.h>
11
11
12 Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
12 Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
13
13
14 class SqpApplication::SqpApplicationPrivate {
14 class SqpApplication::SqpApplicationPrivate {
15 public:
15 public:
16 SqpApplicationPrivate()
16 SqpApplicationPrivate()
17 : m_DataSourceController{std::make_unique<DataSourceController>()},
17 : m_DataSourceController{std::make_unique<DataSourceController>()},
18 m_NetworkController{std::make_unique<NetworkController>()},
18 m_NetworkController{std::make_unique<NetworkController>()},
19 m_TimeController{std::make_unique<TimeController>()},
19 m_TimeController{std::make_unique<TimeController>()},
20 m_VariableController{std::make_unique<VariableController>()},
20 m_VariableController{std::make_unique<VariableController>()},
21 m_VisualizationController{std::make_unique<VisualizationController>()}
21 m_VisualizationController{std::make_unique<VisualizationController>()}
22 {
22 {
23 // /////////////////////////////// //
23 // /////////////////////////////// //
24 // Connections between controllers //
24 // Connections between controllers //
25 // /////////////////////////////// //
25 // /////////////////////////////// //
26
26
27 // VariableController <-> DataSourceController
27 // VariableController <-> DataSourceController
28 connect(m_DataSourceController.get(),
28 connect(m_DataSourceController.get(),
29 SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
29 SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
30 std::shared_ptr<IDataProvider>)),
30 std::shared_ptr<IDataProvider>)),
31 m_VariableController.get(),
31 m_VariableController.get(),
32 SLOT(createVariable(const QString &, const QVariantHash &,
32 SLOT(createVariable(const QString &, const QVariantHash &,
33 std::shared_ptr<IDataProvider>)));
33 std::shared_ptr<IDataProvider>)));
34
34
35 // VariableController <-> VisualizationController
35 // VariableController <-> VisualizationController
36 connect(m_VariableController.get(),
36 connect(m_VariableController.get(),
37 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
37 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
38 m_VisualizationController.get(),
38 m_VisualizationController.get(),
39 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
39 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
40
40
41 connect(m_VariableController.get(),
41 connect(m_VariableController.get(),
42 SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)),
42 SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)),
43 m_VisualizationController.get(),
43 m_VisualizationController.get(),
44 SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
44 SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
45
45
46
46
47 m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
47 m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
48 m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
48 m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
49 m_NetworkController->moveToThread(&m_NetworkControllerThread);
49 m_NetworkController->moveToThread(&m_NetworkControllerThread);
50 m_NetworkControllerThread.setObjectName("NetworkControllerThread");
50 m_NetworkControllerThread.setObjectName("NetworkControllerThread");
51 m_VariableController->moveToThread(&m_VariableControllerThread);
51 m_VariableController->moveToThread(&m_VariableControllerThread);
52 m_VariableControllerThread.setObjectName("VariableControllerThread");
52 m_VariableControllerThread.setObjectName("VariableControllerThread");
53 m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
53 m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
54 m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
54 m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
55
55
56
56
57 // Additionnal init
57 // Additionnal init
58 m_VariableController->setTimeController(m_TimeController.get());
58 m_VariableController->setTimeController(m_TimeController.get());
59 }
59 }
60
60
61 virtual ~SqpApplicationPrivate()
61 virtual ~SqpApplicationPrivate()
62 {
62 {
63 qCInfo(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
63 qCDebug(LOG_SqpApplication()) << tr("SqpApplicationPrivate destruction");
64 m_DataSourceControllerThread.quit();
64 m_DataSourceControllerThread.quit();
65 m_DataSourceControllerThread.wait();
65 m_DataSourceControllerThread.wait();
66
66
67 m_NetworkControllerThread.quit();
67 m_NetworkControllerThread.quit();
68 m_NetworkControllerThread.wait();
68 m_NetworkControllerThread.wait();
69
69
70 m_VariableControllerThread.quit();
70 m_VariableControllerThread.quit();
71 m_VariableControllerThread.wait();
71 m_VariableControllerThread.wait();
72
72
73 m_VisualizationControllerThread.quit();
73 m_VisualizationControllerThread.quit();
74 m_VisualizationControllerThread.wait();
74 m_VisualizationControllerThread.wait();
75 }
75 }
76
76
77 std::unique_ptr<DataSourceController> m_DataSourceController;
77 std::unique_ptr<DataSourceController> m_DataSourceController;
78 std::unique_ptr<VariableController> m_VariableController;
78 std::unique_ptr<VariableController> m_VariableController;
79 std::unique_ptr<TimeController> m_TimeController;
79 std::unique_ptr<TimeController> m_TimeController;
80 std::unique_ptr<NetworkController> m_NetworkController;
80 std::unique_ptr<NetworkController> m_NetworkController;
81 std::unique_ptr<VisualizationController> m_VisualizationController;
81 std::unique_ptr<VisualizationController> m_VisualizationController;
82 QThread m_DataSourceControllerThread;
82 QThread m_DataSourceControllerThread;
83 QThread m_NetworkControllerThread;
83 QThread m_NetworkControllerThread;
84 QThread m_VariableControllerThread;
84 QThread m_VariableControllerThread;
85 QThread m_VisualizationControllerThread;
85 QThread m_VisualizationControllerThread;
86 };
86 };
87
87
88
88
89 SqpApplication::SqpApplication(int &argc, char **argv)
89 SqpApplication::SqpApplication(int &argc, char **argv)
90 : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
90 : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
91 {
91 {
92 qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
92 qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
93
93
94 connect(&impl->m_DataSourceControllerThread, &QThread::started,
94 connect(&impl->m_DataSourceControllerThread, &QThread::started,
95 impl->m_DataSourceController.get(), &DataSourceController::initialize);
95 impl->m_DataSourceController.get(), &DataSourceController::initialize);
96 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
96 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
97 impl->m_DataSourceController.get(), &DataSourceController::finalize);
97 impl->m_DataSourceController.get(), &DataSourceController::finalize);
98
98
99 connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
99 connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
100 &NetworkController::initialize);
100 &NetworkController::initialize);
101 connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
101 connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
102 &NetworkController::finalize);
102 &NetworkController::finalize);
103
103
104 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
104 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
105 &VariableController::initialize);
105 &VariableController::initialize);
106 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
106 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
107 &VariableController::finalize);
107 &VariableController::finalize);
108
108
109 connect(&impl->m_VisualizationControllerThread, &QThread::started,
109 connect(&impl->m_VisualizationControllerThread, &QThread::started,
110 impl->m_VisualizationController.get(), &VisualizationController::initialize);
110 impl->m_VisualizationController.get(), &VisualizationController::initialize);
111 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
111 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
112 impl->m_VisualizationController.get(), &VisualizationController::finalize);
112 impl->m_VisualizationController.get(), &VisualizationController::finalize);
113
113
114 impl->m_DataSourceControllerThread.start();
114 impl->m_DataSourceControllerThread.start();
115 impl->m_NetworkControllerThread.start();
115 impl->m_NetworkControllerThread.start();
116 impl->m_VariableControllerThread.start();
116 impl->m_VariableControllerThread.start();
117 impl->m_VisualizationControllerThread.start();
117 impl->m_VisualizationControllerThread.start();
118 }
118 }
119
119
120 SqpApplication::~SqpApplication()
120 SqpApplication::~SqpApplication()
121 {
121 {
122 }
122 }
123
123
124 void SqpApplication::initialize()
124 void SqpApplication::initialize()
125 {
125 {
126 }
126 }
127
127
128 DataSourceController &SqpApplication::dataSourceController() noexcept
128 DataSourceController &SqpApplication::dataSourceController() noexcept
129 {
129 {
130 return *impl->m_DataSourceController;
130 return *impl->m_DataSourceController;
131 }
131 }
132
132
133 NetworkController &SqpApplication::networkController() noexcept
133 NetworkController &SqpApplication::networkController() noexcept
134 {
134 {
135 return *impl->m_NetworkController;
135 return *impl->m_NetworkController;
136 }
136 }
137
137
138 TimeController &SqpApplication::timeController() noexcept
138 TimeController &SqpApplication::timeController() noexcept
139 {
139 {
140 return *impl->m_TimeController;
140 return *impl->m_TimeController;
141 }
141 }
142
142
143 VariableController &SqpApplication::variableController() noexcept
143 VariableController &SqpApplication::variableController() noexcept
144 {
144 {
145 return *impl->m_VariableController;
145 return *impl->m_VariableController;
146 }
146 }
147
147
148 VisualizationController &SqpApplication::visualizationController() noexcept
148 VisualizationController &SqpApplication::visualizationController() noexcept
149 {
149 {
150 return *impl->m_VisualizationController;
150 return *impl->m_VisualizationController;
151 }
151 }
Show file before | Show file after | Hide comments
@@ -1,427 +1,321
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 /// Gets a tolerance value from application settings. If the setting can't be found, the default
27 /// value passed in parameter is returned
28 double toleranceValue(const QString &key, double defaultValue) noexcept
29 {
30 return QSettings{}.value(key, defaultValue).toDouble();
31 }
32
33 } // namespace
26 } // namespace
34
27
35 struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
28 struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
36
29
37 explicit VisualizationGraphWidgetPrivate()
30 explicit VisualizationGraphWidgetPrivate()
38 : m_DoSynchronize{true}, m_IsCalibration{false}, m_RenderingDelegate{nullptr}
31 : m_DoAcquisition{true}, m_IsCalibration{false}, m_RenderingDelegate{nullptr}
39 {
32 {
40 }
33 }
41
34
42 // Return the operation when range changed
43 VisualizationGraphWidgetZoomType getZoomType(const QCPRange &t1, const QCPRange &t2);
44
45 // 1 variable -> n qcpplot
35 // 1 variable -> n qcpplot
46 std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
36 std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
47 bool m_DoSynchronize;
37 bool m_DoAcquisition;
48 bool m_IsCalibration;
38 bool m_IsCalibration;
49 QCPItemTracer *m_TextTracer;
39 QCPItemTracer *m_TextTracer;
50 /// Delegate used to attach rendering features to the plot
40 /// Delegate used to attach rendering features to the plot
51 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
41 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
52 };
42 };
53
43
54 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
44 VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
55 : QWidget{parent},
45 : QWidget{parent},
56 ui{new Ui::VisualizationGraphWidget},
46 ui{new Ui::VisualizationGraphWidget},
57 impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
47 impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
58 {
48 {
59 ui->setupUi(this);
49 ui->setupUi(this);
60
50
61 // 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
62 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*ui->widget);
52 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*ui->widget);
63
53
64 ui->graphNameLabel->setText(name);
54 ui->graphNameLabel->setText(name);
65
55
66 // 'Close' options : widget is deleted when closed
56 // 'Close' options : widget is deleted when closed
67 setAttribute(Qt::WA_DeleteOnClose);
57 setAttribute(Qt::WA_DeleteOnClose);
68 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationGraphWidget::close);
58 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationGraphWidget::close);
69 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
59 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
70
60
71 // Set qcpplot properties :
61 // Set qcpplot properties :
72 // - Drag (on x-axis) and zoom are enabled
62 // - Drag (on x-axis) and zoom are enabled
73 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
63 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
74 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
64 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
75 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
65 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
76
66
77 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
67 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
78 connect(ui->widget, &QCustomPlot::mouseRelease, this,
68 connect(ui->widget, &QCustomPlot::mouseRelease, this,
79 &VisualizationGraphWidget::onMouseRelease);
69 &VisualizationGraphWidget::onMouseRelease);
80 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
70 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
81 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
71 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
82 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 &)>(
83 &QCPAxis::rangeChanged),
73 &QCPAxis::rangeChanged),
84 this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
74 this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
85
75
86 // Activates menu when right clicking on the graph
76 // Activates menu when right clicking on the graph
87 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
77 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
88 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
78 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
89 &VisualizationGraphWidget::onGraphMenuRequested);
79 &VisualizationGraphWidget::onGraphMenuRequested);
90
80
91 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
81 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
92 &VariableController::onRequestDataLoading);
82 &VariableController::onRequestDataLoading);
93 }
83 }
94
84
95
85
96 VisualizationGraphWidget::~VisualizationGraphWidget()
86 VisualizationGraphWidget::~VisualizationGraphWidget()
97 {
87 {
98 delete ui;
88 delete ui;
99 }
89 }
100
90
101 void VisualizationGraphWidget::enableSynchronize(bool enable)
91 void VisualizationGraphWidget::enableAcquisition(bool enable)
102 {
92 {
103 impl->m_DoSynchronize = enable;
93 impl->m_DoAcquisition = enable;
104 }
94 }
105
95
106 void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
96 void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
107 {
97 {
108 // Uses delegate to create the qcpplot components according to the variable
98 // Uses delegate to create the qcpplot components according to the variable
109 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
99 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
110
100
111 for (auto createdPlottable : qAsConst(createdPlottables)) {
101 for (auto createdPlottable : qAsConst(createdPlottables)) {
112 impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
102 impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
113 }
103 }
114
104
115 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
105 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
116 }
106 }
117 void VisualizationGraphWidget::addVariableUsingGraph(std::shared_ptr<Variable> variable)
107 void VisualizationGraphWidget::addVariableUsingGraph(std::shared_ptr<Variable> variable)
118 {
108 {
109 // TODO
110 // // when adding a variable, we need to set its time range to the current graph range
111 // auto grapheRange = ui->widget->xAxis->range();
112 // auto dateTime = SqpRange{grapheRange.lower, grapheRange.upper};
113 // variable->setDateTime(dateTime);
114
115 // auto variableDateTimeWithTolerance = dateTime;
116
117 // // add tolerance for each side
118 // auto toleranceFactor
119 // = toleranceValue(GENERAL_TOLERANCE_AT_INIT_KEY,
120 // GENERAL_TOLERANCE_AT_INIT_DEFAULT_VALUE);
121 // auto tolerance = toleranceFactor * (dateTime.m_TEnd - dateTime.m_TStart);
122 // variableDateTimeWithTolerance.m_TStart -= tolerance;
123 // variableDateTimeWithTolerance.m_TEnd += tolerance;
124
125 // // Uses delegate to create the qcpplot components according to the variable
126 // auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
127
128 // for (auto createdPlottable : qAsConst(createdPlottables)) {
129 // impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
130 // }
119
131
120 // when adding a variable, we need to set its time range to the current graph range
132 // connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
121 auto grapheRange = ui->widget->xAxis->range();
122 auto dateTime = SqpRange{grapheRange.lower, grapheRange.upper};
123 variable->setDateTime(dateTime);
124
125 auto variableDateTimeWithTolerance = dateTime;
126
127 // add tolerance for each side
128 auto toleranceFactor
129 = toleranceValue(GENERAL_TOLERANCE_AT_INIT_KEY, GENERAL_TOLERANCE_AT_INIT_DEFAULT_VALUE);
130 auto tolerance = toleranceFactor * (dateTime.m_TEnd - dateTime.m_TStart);
131 variableDateTimeWithTolerance.m_TStart -= tolerance;
132 variableDateTimeWithTolerance.m_TEnd += tolerance;
133
134 // Uses delegate to create the qcpplot components according to the variable
135 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
136
137 for (auto createdPlottable : qAsConst(createdPlottables)) {
138 impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
139 }
140
133
141 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
134 // // CHangement detected, we need to ask controller to request data loading
142
135 // emit requestDataLoading(variable, variableDateTimeWithTolerance);
143 // CHangement detected, we need to ask controller to request data loading
144 emit requestDataLoading(variable, variableDateTimeWithTolerance);
145 }
136 }
146
137
147 void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
138 void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
148 {
139 {
149 // Each component associated to the variable :
140 // Each component associated to the variable :
150 // - is removed from qcpplot (which deletes it)
141 // - is removed from qcpplot (which deletes it)
151 // - is no longer referenced in the map
142 // - is no longer referenced in the map
152 auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
143 auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
153 for (auto it = componentsIt.first; it != componentsIt.second;) {
144 for (auto it = componentsIt.first; it != componentsIt.second;) {
154 ui->widget->removePlottable(it->second);
145 ui->widget->removePlottable(it->second);
155 it = impl->m_VariableToPlotMultiMap.erase(it);
146 it = impl->m_VariableToPlotMultiMap.erase(it);
156 }
147 }
157
148
158 // Updates graph
149 // Updates graph
159 ui->widget->replot();
150 ui->widget->replot();
160 }
151 }
161
152
162 void VisualizationGraphWidget::setRange(std::shared_ptr<Variable> variable, const SqpRange &range)
153 void VisualizationGraphWidget::setRange(std::shared_ptr<Variable> variable, const SqpRange &range)
163 {
154 {
164 // Note: in case of different axes that depends on variable, we could start with a code like
155 // Note: in case of different axes that depends on variable, we could start with a code like
165 // that:
156 // that:
166 // auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
157 // auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
167 // for (auto it = componentsIt.first; it != componentsIt.second;) {
158 // for (auto it = componentsIt.first; it != componentsIt.second;) {
168 // }
159 // }
169 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
160 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
170 ui->widget->replot();
161 ui->widget->replot();
171 }
162 }
172
163
173 SqpRange VisualizationGraphWidget::graphRange() const noexcept
164 SqpRange VisualizationGraphWidget::graphRange() const noexcept
174 {
165 {
175 auto grapheRange = ui->widget->xAxis->range();
166 auto grapheRange = ui->widget->xAxis->range();
176 return SqpRange{grapheRange.lower, grapheRange.upper};
167 return SqpRange{grapheRange.lower, grapheRange.upper};
177 }
168 }
178
169
179 void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
170 void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
180 {
171 {
181 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
172 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
182 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
173 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
183 ui->widget->replot();
174 ui->widget->replot();
184 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
175 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
185 }
176 }
186
177
187 void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
178 void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
188 {
179 {
189 if (visitor) {
180 if (visitor) {
190 visitor->visit(this);
181 visitor->visit(this);
191 }
182 }
192 else {
183 else {
193 qCCritical(LOG_VisualizationGraphWidget())
184 qCCritical(LOG_VisualizationGraphWidget())
194 << tr("Can't visit widget : the visitor is null");
185 << tr("Can't visit widget : the visitor is null");
195 }
186 }
196 }
187 }
197
188
198 bool VisualizationGraphWidget::canDrop(const Variable &variable) const
189 bool VisualizationGraphWidget::canDrop(const Variable &variable) const
199 {
190 {
200 /// @todo : for the moment, a graph can always accomodate a variable
191 /// @todo : for the moment, a graph can always accomodate a variable
201 Q_UNUSED(variable);
192 Q_UNUSED(variable);
202 return true;
193 return true;
203 }
194 }
204
195
205 bool VisualizationGraphWidget::contains(const Variable &variable) const
196 bool VisualizationGraphWidget::contains(const Variable &variable) const
206 {
197 {
207 // Finds the variable among the keys of the map
198 // Finds the variable among the keys of the map
208 auto variablePtr = &variable;
199 auto variablePtr = &variable;
209 auto findVariable
200 auto findVariable
210 = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
201 = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
211
202
212 auto end = impl->m_VariableToPlotMultiMap.cend();
203 auto end = impl->m_VariableToPlotMultiMap.cend();
213 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
204 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
214 return it != end;
205 return it != end;
215 }
206 }
216
207
217 QString VisualizationGraphWidget::name() const
208 QString VisualizationGraphWidget::name() const
218 {
209 {
219 return ui->graphNameLabel->text();
210 return ui->graphNameLabel->text();
220 }
211 }
221
212
222 void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
213 void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
223 {
214 {
224 QMenu graphMenu{};
215 QMenu graphMenu{};
225
216
226 // Iterates on variables (unique keys)
217 // Iterates on variables (unique keys)
227 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
218 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
228 end = impl->m_VariableToPlotMultiMap.cend();
219 end = impl->m_VariableToPlotMultiMap.cend();
229 it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
220 it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
230 // 'Remove variable' action
221 // 'Remove variable' action
231 graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
222 graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
232 [ this, var = it->first ]() { removeVariable(var); });
223 [ this, var = it->first ]() { removeVariable(var); });
233 }
224 }
234
225
235 if (!graphMenu.isEmpty()) {
226 if (!graphMenu.isEmpty()) {
236 graphMenu.exec(mapToGlobal(pos));
227 graphMenu.exec(mapToGlobal(pos));
237 }
228 }
238 }
229 }
239
230
240 void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
231 void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
241 {
232 {
242 qCInfo(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged")
233 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
243 << QThread::currentThread()->objectName();
234 << QThread::currentThread()->objectName() << "DoAcqui"
235 << impl->m_DoAcquisition;
244
236
245 auto dateTimeRange = SqpRange{t1.lower, t1.upper};
237 auto graphRange = SqpRange{t1.lower, t1.upper};
238 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
246
239
247 auto zoomType = impl->getZoomType(t1, t2);
240 if (impl->m_DoAcquisition) {
248 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
241 QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
249 it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
250
242
251 auto variable = it->first;
243 for (auto it = impl->m_VariableToPlotMultiMap.begin(),
252 auto currentDateTime = dateTimeRange;
244 end = impl->m_VariableToPlotMultiMap.end();
253
245 it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
254 auto toleranceFactor = toleranceValue(GENERAL_TOLERANCE_AT_UPDATE_KEY,
246 variableUnderGraphVector.push_back(it->first);
255 GENERAL_TOLERANCE_AT_UPDATE_DEFAULT_VALUE);
256 auto tolerance = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
257 auto variableDateTimeWithTolerance = currentDateTime;
258 variableDateTimeWithTolerance.m_TStart -= tolerance;
259 variableDateTimeWithTolerance.m_TEnd += tolerance;
260
261 qCDebug(LOG_VisualizationGraphWidget()) << "r" << currentDateTime;
262 qCDebug(LOG_VisualizationGraphWidget()) << "t" << variableDateTimeWithTolerance;
263 qCDebug(LOG_VisualizationGraphWidget()) << "v" << variable->dateTime();
264 // If new range with tol is upper than variable datetime parameters. we need to request new
265 // data
266 if (!variable->contains(variableDateTimeWithTolerance)) {
267
268 auto variableDateTimeWithTolerance = currentDateTime;
269 if (!variable->isInside(currentDateTime)) {
270 auto variableDateTime = variable->dateTime();
271 if (variable->contains(variableDateTimeWithTolerance)) {
272 qCDebug(LOG_VisualizationGraphWidget())
273 << tr("TORM: Detection zoom in that need request:");
274 // add tolerance for each side
275 tolerance
276 = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
277 variableDateTimeWithTolerance.m_TStart -= tolerance;
278 variableDateTimeWithTolerance.m_TEnd += tolerance;
279 }
280 else if (variableDateTime.m_TStart < currentDateTime.m_TStart) {
281 qCInfo(LOG_VisualizationGraphWidget()) << tr("TORM: Detection pan to right:");
282
283 auto diffEndToKeepDelta = currentDateTime.m_TEnd - variableDateTime.m_TEnd;
284 currentDateTime.m_TStart = variableDateTime.m_TStart + diffEndToKeepDelta;
285 // Tolerance have to be added to the right
286 // add tolerance for right (end) side
287 tolerance
288 = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
289 variableDateTimeWithTolerance.m_TEnd += tolerance;
290 }
291 else if (variableDateTime.m_TEnd > currentDateTime.m_TEnd) {
292 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: Detection pan to left: ");
293 auto diffStartToKeepDelta
294 = variableDateTime.m_TStart - currentDateTime.m_TStart;
295 currentDateTime.m_TEnd = variableDateTime.m_TEnd - diffStartToKeepDelta;
296 // Tolerance have to be added to the left
297 // add tolerance for left (start) side
298 tolerance
299 = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
300 variableDateTimeWithTolerance.m_TStart -= tolerance;
301 }
302 else {
303 qCCritical(LOG_VisualizationGraphWidget())
304 << tr("Detection anormal zoom detection: ");
305 }
306 }
307 else {
308 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: Detection zoom out: ");
309 // add tolerance for each side
310 tolerance = toleranceFactor * (currentDateTime.m_TEnd - currentDateTime.m_TStart);
311 variableDateTimeWithTolerance.m_TStart -= tolerance;
312 variableDateTimeWithTolerance.m_TEnd += tolerance;
313 zoomType = VisualizationGraphWidgetZoomType::ZoomOut;
314 }
315 if (!variable->contains(dateTimeRange)) {
316 qCDebug(LOG_VisualizationGraphWidget())
317 << "TORM: Modif on variable datetime detected" << currentDateTime;
318 variable->setDateTime(currentDateTime);
319 }
320
321 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: Request data detection: ");
322 // CHangement detected, we need to ask controller to request data loading
323 emit requestDataLoading(variable, variableDateTimeWithTolerance);
324 }
247 }
325 else {
248 emit requestDataLoading(std::move(variableUnderGraphVector), graphRange, oldGraphRange,
326 qCInfo(LOG_VisualizationGraphWidget())
249 !impl->m_IsCalibration);
327 << tr("TORM: Detection zoom in that doesn't need request: ");
250
328 zoomType = VisualizationGraphWidgetZoomType::ZoomIn;
251 if (!impl->m_IsCalibration) {
252 qCDebug(LOG_VisualizationGraphWidget())
253 << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
254 << QThread::currentThread()->objectName();
255 emit synchronize(graphRange, oldGraphRange);
329 }
256 }
330 }
257 }
331
332 if (impl->m_DoSynchronize && !impl->m_IsCalibration) {
333 auto oldDateTime = SqpRange{t2.lower, t2.upper};
334 qCDebug(LOG_VisualizationGraphWidget())
335 << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
336 << QThread::currentThread()->objectName();
337 emit synchronize(dateTimeRange, oldDateTime, zoomType);
338 }
339 }
258 }
340
259
341 void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
260 void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
342 {
261 {
343 // Handles plot rendering when mouse is moving
262 // Handles plot rendering when mouse is moving
344 impl->m_RenderingDelegate->onMouseMove(event);
263 impl->m_RenderingDelegate->onMouseMove(event);
345 }
264 }
346
265
347 void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
266 void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
348 {
267 {
349 auto zoomOrientations = QFlags<Qt::Orientation>{};
268 auto zoomOrientations = QFlags<Qt::Orientation>{};
350
269
351 // Lambda that enables a zoom orientation if the key modifier related to this orientation
270 // Lambda that enables a zoom orientation if the key modifier related to this orientation
352 // has
271 // has
353 // been pressed
272 // been pressed
354 auto enableOrientation
273 auto enableOrientation
355 = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
274 = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
356 auto orientationEnabled = event->modifiers().testFlag(modifier);
275 auto orientationEnabled = event->modifiers().testFlag(modifier);
357 zoomOrientations.setFlag(orientation, orientationEnabled);
276 zoomOrientations.setFlag(orientation, orientationEnabled);
358 };
277 };
359 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
278 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
360 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
279 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
361
280
362 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
281 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
363 }
282 }
364
283
365 void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
284 void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
366 {
285 {
367 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
286 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
368 }
287 }
369
288
370 void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
289 void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
371 {
290 {
372 impl->m_IsCalibration = false;
291 impl->m_IsCalibration = false;
373 }
292 }
374
293
375 void VisualizationGraphWidget::onDataCacheVariableUpdated()
294 void VisualizationGraphWidget::onDataCacheVariableUpdated()
376 {
295 {
377 // NOTE:
296 // NOTE:
378 // We don't want to call the method for each component of a variable unitarily, but for
297 // We don't want to call the method for each component of a variable unitarily, but for
379 // all
298 // all
380 // its components at once (eg its three components in the case of a vector).
299 // its components at once (eg its three components in the case of a vector).
381
300
382 // The unordered_multimap does not do this easily, so the question is whether to:
301 // The unordered_multimap does not do this easily, so the question is whether to:
383 // - use an ordered_multimap and the algos of std to group the values by key
302 // - use an ordered_multimap and the algos of std to group the values by key
384 // - use a map (unique keys) and store as values directly the list of components
303 // - use a map (unique keys) and store as values directly the list of components
385
304
386 auto grapheRange = ui->widget->xAxis->range();
305 auto grapheRange = ui->widget->xAxis->range();
387 auto dateTime = SqpRange{grapheRange.lower, grapheRange.upper};
306 auto dateTime = SqpRange{grapheRange.lower, grapheRange.upper};
388
307
389 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
308 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
390 it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
309 it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
391 auto variable = it->first;
310 auto variable = it->first;
392 qCDebug(LOG_VisualizationGraphWidget())
311 qCDebug(LOG_VisualizationGraphWidget())
393 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S"
312 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
394 << variable->dateTime();
395 qCDebug(LOG_VisualizationGraphWidget())
313 qCDebug(LOG_VisualizationGraphWidget())
396 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
314 << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
397 if (dateTime.contains(variable->dateTime()) || dateTime.intersect(variable->dateTime())) {
315 if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
398
316
399 VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
317 VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
400 variable->dataSeries(), variable->dateTime());
318 variable->dataSeries(), variable->range());
401 }
319 }
402 }
320 }
403 }
321 }
404
405 VisualizationGraphWidgetZoomType
406 VisualizationGraphWidget::VisualizationGraphWidgetPrivate::getZoomType(const QCPRange &t1,
407 const QCPRange &t2)
408 {
409 // t1.lower <= t2.lower && t2.upper <= t1.upper
410 auto zoomType = VisualizationGraphWidgetZoomType::Unknown;
411 if (t1.lower <= t2.lower && t2.upper <= t1.upper) {
412 zoomType = VisualizationGraphWidgetZoomType::ZoomOut;
413 }
414 else if (t1.lower > t2.lower && t1.upper > t2.upper) {
415 zoomType = VisualizationGraphWidgetZoomType::PanRight;
416 }
417 else if (t1.lower < t2.lower && t1.upper < t2.upper) {
418 zoomType = VisualizationGraphWidgetZoomType::PanLeft;
419 }
420 else if (t1.lower > t2.lower && t2.upper > t1.upper) {
421 zoomType = VisualizationGraphWidgetZoomType::ZoomIn;
422 }
423 else {
424 qCCritical(LOG_VisualizationGraphWidget()) << "getZoomType: Unknown type detected";
425 }
426 return zoomType;
427 }
Show file before | Show file after | Hide comments
@@ -1,200 +1,215
1 #include "Visualization/VisualizationZoneWidget.h"
1 #include "Visualization/VisualizationZoneWidget.h"
2
2
3 #include "Data/SqpRange.h"
4
3
5 #include "Visualization/IVisualizationWidgetVisitor.h"
4 #include "Visualization/IVisualizationWidgetVisitor.h"
6 #include "Visualization/VisualizationGraphWidget.h"
5 #include "Visualization/VisualizationGraphWidget.h"
7 #include "ui_VisualizationZoneWidget.h"
6 #include "ui_VisualizationZoneWidget.h"
8
7
8 #include <Data/SqpRange.h>
9 #include <Variable/VariableController.h>
9
10
11 #include <QUuid>
10 #include <SqpApplication.h>
12 #include <SqpApplication.h>
11
13
12 Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
14 Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
13
15
14 namespace {
16 namespace {
15
17
16 /// Minimum height for graph added in zones (in pixels)
18 /// Minimum height for graph added in zones (in pixels)
17 const auto GRAPH_MINIMUM_HEIGHT = 300;
19 const auto GRAPH_MINIMUM_HEIGHT = 300;
18
20
19 /// Generates a default name for a new graph, according to the number of graphs already displayed in
21 /// Generates a default name for a new graph, according to the number of graphs already displayed in
20 /// the zone
22 /// the zone
21 QString defaultGraphName(const QLayout &layout)
23 QString defaultGraphName(const QLayout &layout)
22 {
24 {
23 auto count = 0;
25 auto count = 0;
24 for (auto i = 0; i < layout.count(); ++i) {
26 for (auto i = 0; i < layout.count(); ++i) {
25 if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
27 if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
26 count++;
28 count++;
27 }
29 }
28 }
30 }
29
31
30 return QObject::tr("Graph %1").arg(count + 1);
32 return QObject::tr("Graph %1").arg(count + 1);
31 }
33 }
32
34
33 } // namespace
35 } // namespace
34
36
37 struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
38
39 explicit VisualizationZoneWidgetPrivate() : m_SynchronisationGroupId{QUuid::createUuid()} {}
40 QUuid m_SynchronisationGroupId;
41 };
42
35 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
43 VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
36 : QWidget{parent}, ui{new Ui::VisualizationZoneWidget}
44 : QWidget{parent},
45 ui{new Ui::VisualizationZoneWidget},
46 impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
37 {
47 {
38 ui->setupUi(this);
48 ui->setupUi(this);
39
49
40 ui->zoneNameLabel->setText(name);
50 ui->zoneNameLabel->setText(name);
41
51
42 // 'Close' options : widget is deleted when closed
52 // 'Close' options : widget is deleted when closed
43 setAttribute(Qt::WA_DeleteOnClose);
53 setAttribute(Qt::WA_DeleteOnClose);
44 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
54 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
45 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
55 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
56
57 // Synchronisation id
58 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
59 Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
46 }
60 }
47
61
48 VisualizationZoneWidget::~VisualizationZoneWidget()
62 VisualizationZoneWidget::~VisualizationZoneWidget()
49 {
63 {
50 delete ui;
64 delete ui;
51 }
65 }
52
66
53 void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
67 void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
54 {
68 {
55 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
69 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
56 }
70 }
57
71
58 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
72 VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
59 {
73 {
60 auto graphWidget = new VisualizationGraphWidget{
74 auto graphWidget = new VisualizationGraphWidget{
61 defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
75 defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
62
76
63
77
64 // Set graph properties
78 // Set graph properties
65 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
79 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
66 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
80 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
67
81
68 this->addGraph(graphWidget);
82 this->addGraph(graphWidget);
69
83
70 graphWidget->addVariable(variable);
84 graphWidget->addVariable(variable);
71
85
72 // Lambda to synchronize zone widget
86 // Lambda to synchronize zone widget
73 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &dateTime,
87 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &grapheRange,
74 const SqpRange &oldDateTime,
88 const SqpRange &oldGraphRange) {
75 VisualizationGraphWidgetZoomType zoomType) {
89
90 auto zoomType = VariableController::getZoomType(grapheRange, oldGraphRange);
76 auto frameLayout = ui->visualizationZoneFrame->layout();
91 auto frameLayout = ui->visualizationZoneFrame->layout();
77 for (auto i = 0; i < frameLayout->count(); ++i) {
92 for (auto i = 0; i < frameLayout->count(); ++i) {
78 auto graphChild
93 auto graphChild
79 = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
94 = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
80 if (graphChild && (graphChild != graphWidget)) {
95 if (graphChild && (graphChild != graphWidget)) {
81
96
82 auto graphChildRange = graphChild->graphRange();
97 auto graphChildRange = graphChild->graphRange();
83 switch (zoomType) {
98 switch (zoomType) {
84 case VisualizationGraphWidgetZoomType::ZoomIn: {
99 case AcquisitionZoomType::ZoomIn: {
85 auto deltaLeft = dateTime.m_TStart - oldDateTime.m_TStart;
100 auto deltaLeft = grapheRange.m_TStart - oldGraphRange.m_TStart;
86 auto deltaRight = oldDateTime.m_TEnd - dateTime.m_TEnd;
101 auto deltaRight = oldGraphRange.m_TEnd - grapheRange.m_TEnd;
87 graphChildRange.m_TStart += deltaLeft;
102 graphChildRange.m_TStart += deltaLeft;
88 graphChildRange.m_TEnd -= deltaRight;
103 graphChildRange.m_TEnd -= deltaRight;
89 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
104 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
90 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
105 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
91 << deltaLeft;
106 << deltaLeft;
92 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
107 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
93 << deltaRight;
108 << deltaRight;
94 qCCritical(LOG_VisualizationZoneWidget())
109 qCCritical(LOG_VisualizationZoneWidget())
95 << tr("TORM: dt") << dateTime.m_TEnd - dateTime.m_TStart;
110 << tr("TORM: dt") << grapheRange.m_TEnd - grapheRange.m_TStart;
96
111
97 break;
112 break;
98 }
113 }
99
114
100 case VisualizationGraphWidgetZoomType::ZoomOut: {
115 case AcquisitionZoomType::ZoomOut: {
101 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
116 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
102 auto deltaLeft = oldDateTime.m_TStart - dateTime.m_TStart;
117 auto deltaLeft = oldGraphRange.m_TStart - grapheRange.m_TStart;
103 auto deltaRight = dateTime.m_TEnd - oldDateTime.m_TEnd;
118 auto deltaRight = grapheRange.m_TEnd - oldGraphRange.m_TEnd;
104 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
119 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
105 << deltaLeft;
120 << deltaLeft;
106 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
121 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
107 << deltaRight;
122 << deltaRight;
108 qCCritical(LOG_VisualizationZoneWidget())
123 qCCritical(LOG_VisualizationZoneWidget())
109 << tr("TORM: dt") << dateTime.m_TEnd - dateTime.m_TStart;
124 << tr("TORM: dt") << grapheRange.m_TEnd - grapheRange.m_TStart;
110 graphChildRange.m_TStart -= deltaLeft;
125 graphChildRange.m_TStart -= deltaLeft;
111 graphChildRange.m_TEnd += deltaRight;
126 graphChildRange.m_TEnd += deltaRight;
112 break;
127 break;
113 }
128 }
114 case VisualizationGraphWidgetZoomType::PanRight: {
129 case AcquisitionZoomType::PanRight: {
115 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
130 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
116 auto deltaRight = dateTime.m_TEnd - oldDateTime.m_TEnd;
131 auto deltaRight = grapheRange.m_TEnd - oldGraphRange.m_TEnd;
117 graphChildRange.m_TStart += deltaRight;
132 graphChildRange.m_TStart += deltaRight;
118 graphChildRange.m_TEnd += deltaRight;
133 graphChildRange.m_TEnd += deltaRight;
119 qCCritical(LOG_VisualizationZoneWidget())
134 qCCritical(LOG_VisualizationZoneWidget())
120 << tr("TORM: dt") << dateTime.m_TEnd - dateTime.m_TStart;
135 << tr("TORM: dt") << grapheRange.m_TEnd - grapheRange.m_TStart;
121 break;
136 break;
122 }
137 }
123 case VisualizationGraphWidgetZoomType::PanLeft: {
138 case AcquisitionZoomType::PanLeft: {
124 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
139 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
125 auto deltaLeft = oldDateTime.m_TStart - dateTime.m_TStart;
140 auto deltaLeft = oldGraphRange.m_TStart - grapheRange.m_TStart;
126 graphChildRange.m_TStart -= deltaLeft;
141 graphChildRange.m_TStart -= deltaLeft;
127 graphChildRange.m_TEnd -= deltaLeft;
142 graphChildRange.m_TEnd -= deltaLeft;
128 break;
143 break;
129 }
144 }
130 case VisualizationGraphWidgetZoomType::Unknown: {
145 case AcquisitionZoomType::Unknown: {
131 qCCritical(LOG_VisualizationZoneWidget())
146 qCCritical(LOG_VisualizationZoneWidget())
132 << tr("Impossible to synchronize: zoom type unknown");
147 << tr("Impossible to synchronize: zoom type unknown");
133 break;
148 break;
134 }
149 }
135 default:
150 default:
136 qCCritical(LOG_VisualizationZoneWidget())
151 qCCritical(LOG_VisualizationZoneWidget())
137 << tr("Impossible to synchronize: zoom type not take into account");
152 << tr("Impossible to synchronize: zoom type not take into account");
138 // No action
153 // No action
139 break;
154 break;
140 }
155 }
141 graphChild->enableSynchronize(false);
156 graphChild->enableAcquisition(false);
142 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
157 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
143 << graphChild->graphRange();
158 << graphChild->graphRange();
144 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
159 qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
145 << graphChildRange;
160 << graphChildRange;
146 qCCritical(LOG_VisualizationZoneWidget())
161 qCCritical(LOG_VisualizationZoneWidget())
147 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
162 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
148 graphChild->setGraphRange(graphChildRange);
163 graphChild->setGraphRange(graphChildRange);
149 graphChild->enableSynchronize(true);
164 graphChild->enableAcquisition(true);
150 }
165 }
151 }
166 }
152 };
167 };
153
168
154 // connection for synchronization
169 // connection for synchronization
155 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
170 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
156
171
157 return graphWidget;
172 return graphWidget;
158 }
173 }
159
174
160 void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
175 void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
161 {
176 {
162 if (visitor) {
177 if (visitor) {
163 visitor->visitEnter(this);
178 visitor->visitEnter(this);
164
179
165 // Apply visitor to graph children
180 // Apply visitor to graph children
166 auto layout = ui->visualizationZoneFrame->layout();
181 auto layout = ui->visualizationZoneFrame->layout();
167 for (auto i = 0; i < layout->count(); ++i) {
182 for (auto i = 0; i < layout->count(); ++i) {
168 if (auto item = layout->itemAt(i)) {
183 if (auto item = layout->itemAt(i)) {
169 // Widgets different from graphs are not visited (no action)
184 // Widgets different from graphs are not visited (no action)
170 if (auto visualizationGraphWidget
185 if (auto visualizationGraphWidget
171 = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
186 = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
172 visualizationGraphWidget->accept(visitor);
187 visualizationGraphWidget->accept(visitor);
173 }
188 }
174 }
189 }
175 }
190 }
176
191
177 visitor->visitLeave(this);
192 visitor->visitLeave(this);
178 }
193 }
179 else {
194 else {
180 qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
195 qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
181 }
196 }
182 }
197 }
183
198
184 bool VisualizationZoneWidget::canDrop(const Variable &variable) const
199 bool VisualizationZoneWidget::canDrop(const Variable &variable) const
185 {
200 {
186 // A tab can always accomodate a variable
201 // A tab can always accomodate a variable
187 Q_UNUSED(variable);
202 Q_UNUSED(variable);
188 return true;
203 return true;
189 }
204 }
190
205
191 bool VisualizationZoneWidget::contains(const Variable &variable) const
206 bool VisualizationZoneWidget::contains(const Variable &variable) const
192 {
207 {
193 Q_UNUSED(variable);
208 Q_UNUSED(variable);
194 return false;
209 return false;
195 }
210 }
196
211
197 QString VisualizationZoneWidget::name() const
212 QString VisualizationZoneWidget::name() const
198 {
213 {
199 return ui->zoneNameLabel->text();
214 return ui->zoneNameLabel->text();
200 }
215 }
Show file before | Show file after | Hide comments
@@ -1,30 +1,30
1 #ifndef SCIQLOP_AMDAPROVIDER_H
1 #ifndef SCIQLOP_AMDAPROVIDER_H
2 #define SCIQLOP_AMDAPROVIDER_H
2 #define SCIQLOP_AMDAPROVIDER_H
3
3
4 #include "AmdaGlobal.h"
4 #include "AmdaGlobal.h"
5
5
6 #include <Data/IDataProvider.h>
6 #include <Data/IDataProvider.h>
7
7
8 #include <QLoggingCategory>
8 #include <QLoggingCategory>
9
9
10
10
11 Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaProvider)
11 Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaProvider)
12
12
13 class QNetworkReply;
13 class QNetworkReply;
14
14
15 /**
15 /**
16 * @brief The AmdaProvider class is an example of how a data provider can generate data
16 * @brief The AmdaProvider class is an example of how a data provider can generate data
17 */
17 */
18 class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider {
18 class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider {
19 public:
19 public:
20 explicit AmdaProvider();
20 explicit AmdaProvider();
21
21
22 void requestDataLoading(QUuid token, const DataProviderParameters &parameters) override;
22 void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override;
23
23
24 void requestDataAborting(QUuid identifier) override;
24 void requestDataAborting(QUuid acqIdentifier) override;
25
25
26 private:
26 private:
27 void retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data);
27 void retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data);
28 };
28 };
29
29
30 #endif // SCIQLOP_AMDAPROVIDER_H
30 #endif // SCIQLOP_AMDAPROVIDER_H
Show file before | Show file after | Hide comments
@@ -1,147 +1,147
1 #include "AmdaProvider.h"
1 #include "AmdaProvider.h"
2 #include "AmdaDefs.h"
2 #include "AmdaDefs.h"
3 #include "AmdaResultParser.h"
3 #include "AmdaResultParser.h"
4
4
5 #include <Common/DateUtils.h>
5 #include <Common/DateUtils.h>
6 #include <Data/DataProviderParameters.h>
6 #include <Data/DataProviderParameters.h>
7 #include <Network/NetworkController.h>
7 #include <Network/NetworkController.h>
8 #include <SqpApplication.h>
8 #include <SqpApplication.h>
9 #include <Variable/Variable.h>
9 #include <Variable/Variable.h>
10
10
11 #include <QNetworkAccessManager>
11 #include <QNetworkAccessManager>
12 #include <QNetworkReply>
12 #include <QNetworkReply>
13 #include <QTemporaryFile>
13 #include <QTemporaryFile>
14 #include <QThread>
14 #include <QThread>
15
15
16 Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
16 Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
17
17
18 namespace {
18 namespace {
19
19
20 /// URL format for a request on AMDA server. The parameters are as follows:
20 /// URL format for a request on AMDA server. The parameters are as follows:
21 /// - %1: start date
21 /// - %1: start date
22 /// - %2: end date
22 /// - %2: end date
23 /// - %3: parameter id
23 /// - %3: parameter id
24 const auto AMDA_URL_FORMAT = QStringLiteral(
24 const auto AMDA_URL_FORMAT = QStringLiteral(
25 "http://amda.irap.omp.eu/php/rest/"
25 "http://amda.irap.omp.eu/php/rest/"
26 "getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&outputFormat=ASCII&"
26 "getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&outputFormat=ASCII&"
27 "timeFormat=ISO8601&gzip=0");
27 "timeFormat=ISO8601&gzip=0");
28
28
29 /// Dates format passed in the URL (e.g 2013-09-23T09:00)
29 /// Dates format passed in the URL (e.g 2013-09-23T09:00)
30 const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
30 const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
31
31
32 /// Formats a time to a date that can be passed in URL
32 /// Formats a time to a date that can be passed in URL
33 QString dateFormat(double sqpRange) noexcept
33 QString dateFormat(double sqpRange) noexcept
34 {
34 {
35 auto dateTime = DateUtils::dateTime(sqpRange);
35 auto dateTime = DateUtils::dateTime(sqpRange);
36 return dateTime.toString(AMDA_TIME_FORMAT);
36 return dateTime.toString(AMDA_TIME_FORMAT);
37 }
37 }
38
38
39 } // namespace
39 } // namespace
40
40
41 AmdaProvider::AmdaProvider()
41 AmdaProvider::AmdaProvider()
42 {
42 {
43 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
43 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
44 if (auto app = sqpApp) {
44 if (auto app = sqpApp) {
45 auto &networkController = app->networkController();
45 auto &networkController = app->networkController();
46 connect(this, SIGNAL(requestConstructed(QNetworkRequest, QUuid,
46 connect(this, SIGNAL(requestConstructed(QNetworkRequest, QUuid,
47 std::function<void(QNetworkReply *, QUuid)>)),
47 std::function<void(QNetworkReply *, QUuid)>)),
48 &networkController,
48 &networkController,
49 SLOT(onProcessRequested(QNetworkRequest, QUuid,
49 SLOT(onProcessRequested(QNetworkRequest, QUuid,
50 std::function<void(QNetworkReply *, QUuid)>)));
50 std::function<void(QNetworkReply *, QUuid)>)));
51
51
52
52
53 connect(&sqpApp->networkController(), SIGNAL(replyDownloadProgress(QUuid, double)), this,
53 connect(&sqpApp->networkController(), SIGNAL(replyDownloadProgress(QUuid, double)), this,
54 SIGNAL(dataProvidedProgress(QUuid, double)));
54 SIGNAL(dataProvidedProgress(QUuid, double)));
55 }
55 }
56 }
56 }
57
57
58 void AmdaProvider::requestDataLoading(QUuid token, const DataProviderParameters &parameters)
58 void AmdaProvider::requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters)
59 {
59 {
60 // NOTE: Try to use multithread if possible
60 // NOTE: Try to use multithread if possible
61 const auto times = parameters.m_Times;
61 const auto times = parameters.m_Times;
62 const auto data = parameters.m_Data;
62 const auto data = parameters.m_Data;
63 for (const auto &dateTime : qAsConst(times)) {
63 for (const auto &dateTime : qAsConst(times)) {
64 retrieveData(token, dateTime, data);
64 retrieveData(acqIdentifier, dateTime, data);
65 }
65 }
66 }
66 }
67
67
68 void AmdaProvider::requestDataAborting(QUuid identifier)
68 void AmdaProvider::requestDataAborting(QUuid acqIdentifier)
69 {
69 {
70 if (auto app = sqpApp) {
70 if (auto app = sqpApp) {
71 auto &networkController = app->networkController();
71 auto &networkController = app->networkController();
72 networkController.onReplyCanceled(identifier);
72 networkController.onReplyCanceled(acqIdentifier);
73 }
73 }
74 }
74 }
75
75
76 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)
76 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)
77 {
77 {
78 // Retrieves product ID from data: if the value is invalid, no request is made
78 // Retrieves product ID from data: if the value is invalid, no request is made
79 auto productId = data.value(AMDA_XML_ID_KEY).toString();
79 auto productId = data.value(AMDA_XML_ID_KEY).toString();
80 if (productId.isNull()) {
80 if (productId.isNull()) {
81 qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
81 qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
82 return;
82 return;
83 }
83 }
84 qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData") << dateTime;
84 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData") << dateTime;
85
85
86 // /////////// //
86 // /////////// //
87 // Creates URL //
87 // Creates URL //
88 // /////////// //
88 // /////////// //
89
89
90 auto startDate = dateFormat(dateTime.m_TStart);
90 auto startDate = dateFormat(dateTime.m_TStart);
91 auto endDate = dateFormat(dateTime.m_TEnd);
91 auto endDate = dateFormat(dateTime.m_TEnd);
92
92
93 auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
93 auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
94 qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData url:") << url;
94 qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData url:") << url;
95 auto tempFile = std::make_shared<QTemporaryFile>();
95 auto tempFile = std::make_shared<QTemporaryFile>();
96
96
97 // LAMBDA
97 // LAMBDA
98 auto httpDownloadFinished
98 auto httpDownloadFinished
99 = [this, dateTime, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
99 = [this, dateTime, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
100
100
101 // Don't do anything if the reply was abort
101 // Don't do anything if the reply was abort
102 if (reply->error() != QNetworkReply::OperationCanceledError) {
102 if (reply->error() != QNetworkReply::OperationCanceledError) {
103
103
104 if (tempFile) {
104 if (tempFile) {
105 auto replyReadAll = reply->readAll();
105 auto replyReadAll = reply->readAll();
106 if (!replyReadAll.isEmpty()) {
106 if (!replyReadAll.isEmpty()) {
107 tempFile->write(replyReadAll);
107 tempFile->write(replyReadAll);
108 }
108 }
109 tempFile->close();
109 tempFile->close();
110
110
111 // Parse results file
111 // Parse results file
112 if (auto dataSeries = AmdaResultParser::readTxt(tempFile->fileName())) {
112 if (auto dataSeries = AmdaResultParser::readTxt(tempFile->fileName())) {
113 emit dataProvided(dataId, dataSeries, dateTime);
113 emit dataProvided(dataId, dataSeries, dateTime);
114 }
114 }
115 else {
115 else {
116 /// @todo ALX : debug
116 /// @todo ALX : debug
117 }
117 }
118 }
118 }
119 }
119 }
120
120
121 };
121 };
122 auto httpFinishedLambda
122 auto httpFinishedLambda
123 = [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
123 = [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
124
124
125 // Don't do anything if the reply was abort
125 // Don't do anything if the reply was abort
126 if (reply->error() != QNetworkReply::OperationCanceledError) {
126 if (reply->error() != QNetworkReply::OperationCanceledError) {
127 auto downloadFileUrl = QUrl{QString{reply->readAll()}};
127 auto downloadFileUrl = QUrl{QString{reply->readAll()}};
128
128
129
129
130 qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData downloadFileUrl:")
130 qCInfo(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData downloadFileUrl:")
131 << downloadFileUrl;
131 << downloadFileUrl;
132 // Executes request for downloading file //
132 // Executes request for downloading file //
133
133
134 // Creates destination file
134 // Creates destination file
135 if (tempFile->open()) {
135 if (tempFile->open()) {
136 // Executes request
136 // Executes request
137 emit requestConstructed(QNetworkRequest{downloadFileUrl}, dataId,
137 emit requestConstructed(QNetworkRequest{downloadFileUrl}, dataId,
138 httpDownloadFinished);
138 httpDownloadFinished);
139 }
139 }
140 }
140 }
141 };
141 };
142
142
143 // //////////////// //
143 // //////////////// //
144 // Executes request //
144 // Executes request //
145 // //////////////// //
145 // //////////////// //
146 emit requestConstructed(QNetworkRequest{url}, token, httpFinishedLambda);
146 emit requestConstructed(QNetworkRequest{url}, token, httpFinishedLambda);
147 }
147 }
Show file before | Show file after | Hide comments
@@ -1,33 +1,34
1 #ifndef SCIQLOP_COSINUSPROVIDER_H
1 #ifndef SCIQLOP_COSINUSPROVIDER_H
2 #define SCIQLOP_COSINUSPROVIDER_H
2 #define SCIQLOP_COSINUSPROVIDER_H
3
3
4 #include "MockPluginGlobal.h"
4 #include "MockPluginGlobal.h"
5
5
6 #include <Data/IDataProvider.h>
6 #include <Data/IDataProvider.h>
7
7
8 #include <QLoggingCategory>
8 #include <QLoggingCategory>
9 #include <QUuid>
9 #include <QUuid>
10
10
11 #include <QHash>
11 #include <QHash>
12 Q_DECLARE_LOGGING_CATEGORY(LOG_CosinusProvider)
12 Q_DECLARE_LOGGING_CATEGORY(LOG_CosinusProvider)
13
13
14 /**
14 /**
15 * @brief The CosinusProvider class is an example of how a data provider can generate data
15 * @brief The CosinusProvider class is an example of how a data provider can generate data
16 */
16 */
17 class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider {
17 class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider {
18 public:
18 public:
19 /// @sa IDataProvider::requestDataLoading(). The current impl isn't thread safe.
19 /// @sa IDataProvider::requestDataLoading(). The current impl isn't thread safe.
20 void requestDataLoading(QUuid token, const DataProviderParameters &parameters) override;
20 void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override;
21
21
22
22
23 /// @sa IDataProvider::requestDataAborting(). The current impl isn't thread safe.
23 /// @sa IDataProvider::requestDataAborting(). The current impl isn't thread safe.
24 void requestDataAborting(QUuid identifier) override;
24 void requestDataAborting(QUuid acqIdentifier) override;
25
25
26
26
27 private:
27 private:
28 std::shared_ptr<IDataSeries> retrieveData(QUuid token, const SqpRange &dateTime);
28 std::shared_ptr<IDataSeries> retrieveData(QUuid acqIdentifier,
29 const SqpRange &dataRangeRequested);
29
30
30 QHash<QUuid, bool> m_VariableToEnableProvider;
31 QHash<QUuid, bool> m_VariableToEnableProvider;
31 };
32 };
32
33
33 #endif // SCIQLOP_COSINUSPROVIDER_H
34 #endif // SCIQLOP_COSINUSPROVIDER_H
Show file before | Show file after | Hide comments
@@ -1,100 +1,102
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 token, const SqpRange &dateTime)
14 std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
15 const SqpRange &dataRangeRequested)
15 {
16 {
16 // TODO: Add Mutex
17 // TODO: Add Mutex
17 auto dataIndex = 0;
18 auto dataIndex = 0;
18
19
19 // Gets the timerange from the parameters
20 // Gets the timerange from the parameters
20 double freq = 100.0;
21 double freq = 100.0;
21 double start = std::ceil(dateTime.m_TStart * freq); // 100 htz
22 double start = std::ceil(dataRangeRequested.m_TStart * freq); // 100 htz
22 double end = std::floor(dateTime.m_TEnd * freq); // 100 htz
23 double end = std::floor(dataRangeRequested.m_TEnd * freq); // 100 htz
23
24
24 // We assure that timerange is valid
25 // We assure that timerange is valid
25 if (end < start) {
26 if (end < start) {
26 std::swap(start, end);
27 std::swap(start, end);
27 }
28 }
28
29
29 // Generates scalar series containing cosinus values (one value per second)
30 // Generates scalar series containing cosinus values (one value per second)
30 auto dataCount = end - start;
31 auto dataCount = end - start;
31
32
32 auto xAxisData = QVector<double>{};
33 auto xAxisData = QVector<double>{};
33 xAxisData.resize(dataCount);
34 xAxisData.resize(dataCount);
34
35
35 auto valuesData = QVector<double>{};
36 auto valuesData = QVector<double>{};
36 valuesData.resize(dataCount);
37 valuesData.resize(dataCount);
37
38
38 int progress = 0;
39 int progress = 0;
39 auto progressEnd = dataCount;
40 auto progressEnd = dataCount;
40 for (auto time = start; time < end; ++time, ++dataIndex) {
41 for (auto time = start; time < end; ++time, ++dataIndex) {
41 auto it = m_VariableToEnableProvider.find(token);
42 auto it = m_VariableToEnableProvider.find(acqIdentifier);
42 if (it != m_VariableToEnableProvider.end() && it.value()) {
43 if (it != m_VariableToEnableProvider.end() && it.value()) {
43 const auto timeOnFreq = time / freq;
44 const auto timeOnFreq = time / freq;
44
45
45 xAxisData.replace(dataIndex, timeOnFreq);
46 xAxisData.replace(dataIndex, timeOnFreq);
46 valuesData.replace(dataIndex, std::cos(timeOnFreq));
47 valuesData.replace(dataIndex, std::cos(timeOnFreq));
47
48
48 // progression
49 // progression
49 int currentProgress = (time - start) * 100.0 / progressEnd;
50 int currentProgress = (time - start) * 100.0 / progressEnd;
50 if (currentProgress != progress) {
51 if (currentProgress != progress) {
51 progress = currentProgress;
52 progress = currentProgress;
52
53
53 emit dataProvidedProgress(token, progress);
54 emit dataProvidedProgress(acqIdentifier, progress);
54 }
55 }
55 }
56 }
56 else {
57 else {
57 if (!it.value()) {
58 if (!it.value()) {
58 qCDebug(LOG_CosinusProvider())
59 qCDebug(LOG_CosinusProvider())
59 << "CosinusProvider::retrieveData: ARRET De l'acquisition detecté"
60 << "CosinusProvider::retrieveData: ARRET De l'acquisition detecté"
60 << end - time;
61 << end - time;
61 }
62 }
62 }
63 }
63 }
64 }
64 emit dataProvidedProgress(token, 0.0);
65 emit dataProvidedProgress(acqIdentifier, 0.0);
65
66
66 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
67 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
67 Unit{QStringLiteral("t"), true}, Unit{});
68 Unit{QStringLiteral("t"), true}, Unit{});
68 }
69 }
69
70
70 void CosinusProvider::requestDataLoading(QUuid token, const DataProviderParameters &parameters)
71 void CosinusProvider::requestDataLoading(QUuid acqIdentifier,
72 const DataProviderParameters &parameters)
71 {
73 {
72 // TODO: Add Mutex
74 // TODO: Add Mutex
73 m_VariableToEnableProvider[token] = true;
75 m_VariableToEnableProvider[acqIdentifier] = true;
74 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataLoading"
76 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataLoading"
75 << QThread::currentThread()->objectName();
77 << QThread::currentThread()->objectName();
76 // NOTE: Try to use multithread if possible
78 // NOTE: Try to use multithread if possible
77 const auto times = parameters.m_Times;
79 const auto times = parameters.m_Times;
78
80
79 for (const auto &dateTime : qAsConst(times)) {
81 for (const auto &dateTime : qAsConst(times)) {
80 if (m_VariableToEnableProvider[token]) {
82 if (m_VariableToEnableProvider[acqIdentifier]) {
81 auto scalarSeries = this->retrieveData(token, dateTime);
83 auto scalarSeries = this->retrieveData(acqIdentifier, dateTime);
82 emit dataProvided(token, scalarSeries, dateTime);
84 emit dataProvided(acqIdentifier, scalarSeries, dateTime);
83 }
85 }
84 }
86 }
85 }
87 }
86
88
87 void CosinusProvider::requestDataAborting(QUuid identifier)
89 void CosinusProvider::requestDataAborting(QUuid acqIdentifier)
88 {
90 {
89 // TODO: Add Mutex
91 // TODO: Add Mutex
90 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << identifier
92 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << acqIdentifier
91 << QThread::currentThread()->objectName();
93 << QThread::currentThread()->objectName();
92 auto it = m_VariableToEnableProvider.find(identifier);
94 auto it = m_VariableToEnableProvider.find(acqIdentifier);
93 if (it != m_VariableToEnableProvider.end()) {
95 if (it != m_VariableToEnableProvider.end()) {
94 it.value() = false;
96 it.value() = false;
95 }
97 }
96 else {
98 else {
97 qCWarning(LOG_CosinusProvider())
99 qCWarning(LOG_CosinusProvider())
98 << tr("Aborting progression of inexistant identifier detected !!!");
100 << tr("Aborting progression of inexistant identifier detected !!!");
99 }
101 }
100 }
102 }
General Comments 1
Under Review
perrinel
author
Comment #1865
Edit
Delete
|

Auto status change to "Under Review"

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