@@ -0,0 +1,19 | |||||
|
1 | #ifndef SCIQLOP_COLORUTILS_H | |||
|
2 | #define SCIQLOP_COLORUTILS_H | |||
|
3 | ||||
|
4 | #include <vector> | |||
|
5 | ||||
|
6 | class QColor; | |||
|
7 | ||||
|
8 | /** | |||
|
9 | * Utility class with methods for colors | |||
|
10 | */ | |||
|
11 | struct ColorUtils { | |||
|
12 | /// Generates a color scale from min / max values and a number of colors. | |||
|
13 | /// The algorithm uses the HSV color model to generate color variations (see | |||
|
14 | /// http://doc.qt.io/qt-4.8/qcolor.html#the-hsv-color-model) | |||
|
15 | static std::vector<QColor> colors(const QColor &minColor, const QColor &maxColor, | |||
|
16 | int nbColors) noexcept; | |||
|
17 | }; | |||
|
18 | ||||
|
19 | #endif // SCIQLOP_COLORUTILS_H |
@@ -0,0 +1,10 | |||||
|
1 | #ifndef SCIQLOP_VISUALIZATIONDEFS_H | |||
|
2 | #define SCIQLOP_VISUALIZATIONDEFS_H | |||
|
3 | ||||
|
4 | #include <map> | |||
|
5 | ||||
|
6 | class QCPAbstractPlottable; | |||
|
7 | ||||
|
8 | using PlottablesMap = std::map<int, QCPAbstractPlottable *>; | |||
|
9 | ||||
|
10 | #endif // SCIQLOP_VISUALIZATIONDEFS_H |
@@ -0,0 +1,29 | |||||
|
1 | #include "Common/ColorUtils.h" | |||
|
2 | ||||
|
3 | #include <QtGui/QColor> | |||
|
4 | ||||
|
5 | std::vector<QColor> ColorUtils::colors(const QColor &minColor, const QColor &maxColor, | |||
|
6 | int nbColors) noexcept | |||
|
7 | { | |||
|
8 | auto result = std::vector<QColor>{}; | |||
|
9 | ||||
|
10 | if (nbColors == 1) { | |||
|
11 | result.push_back(minColor); | |||
|
12 | } | |||
|
13 | else if (nbColors > 0) { | |||
|
14 | const auto nbSteps = static_cast<double>(nbColors - 1); | |||
|
15 | ||||
|
16 | const auto colorHStep = (maxColor.hue() - minColor.hue()) / nbSteps; | |||
|
17 | const auto colorSStep = (maxColor.saturation() - minColor.saturation()) / nbSteps; | |||
|
18 | const auto colorVStep = (maxColor.value() - minColor.value()) / nbSteps; | |||
|
19 | const auto colorAStep = (maxColor.alpha() - minColor.alpha()) / nbSteps; | |||
|
20 | ||||
|
21 | for (auto i = 0; i < nbColors; ++i) { | |||
|
22 | result.push_back(QColor::fromHsv( | |||
|
23 | minColor.hue() + i * colorHStep, minColor.saturation() + i * colorSStep, | |||
|
24 | minColor.value() + i * colorVStep, minColor.alpha() + i * colorAStep)); | |||
|
25 | } | |||
|
26 | } | |||
|
27 | ||||
|
28 | return result; | |||
|
29 | } |
@@ -1,313 +1,315 | |||||
1 | #ifndef SCIQLOP_ARRAYDATA_H |
|
1 | #ifndef SCIQLOP_ARRAYDATA_H | |
2 | #define SCIQLOP_ARRAYDATA_H |
|
2 | #define SCIQLOP_ARRAYDATA_H | |
3 |
|
3 | |||
4 | #include <Common/SortUtils.h> |
|
4 | #include <Common/SortUtils.h> | |
5 |
|
5 | |||
6 | #include <QReadLocker> |
|
6 | #include <QReadLocker> | |
7 | #include <QReadWriteLock> |
|
7 | #include <QReadWriteLock> | |
8 | #include <QVector> |
|
8 | #include <QVector> | |
9 |
|
9 | |||
10 | #include <memory> |
|
10 | #include <memory> | |
11 |
|
11 | |||
12 | template <int Dim> |
|
12 | template <int Dim> | |
13 | class ArrayData; |
|
13 | class ArrayData; | |
14 |
|
14 | |||
15 | using DataContainer = QVector<QVector<double> >; |
|
15 | using DataContainer = QVector<QVector<double> >; | |
16 |
|
16 | |||
17 | namespace arraydata_detail { |
|
17 | namespace arraydata_detail { | |
18 |
|
18 | |||
19 | /// Struct used to sort ArrayData |
|
19 | /// Struct used to sort ArrayData | |
20 | template <int Dim> |
|
20 | template <int Dim> | |
21 | struct Sort { |
|
21 | struct Sort { | |
22 | static std::shared_ptr<ArrayData<Dim> > sort(const DataContainer &data, |
|
22 | static std::shared_ptr<ArrayData<Dim> > sort(const DataContainer &data, | |
23 | const std::vector<int> &sortPermutation) |
|
23 | const std::vector<int> &sortPermutation) | |
24 | { |
|
24 | { | |
25 | auto nbComponents = data.size(); |
|
25 | auto nbComponents = data.size(); | |
26 | auto sortedData = DataContainer(nbComponents); |
|
26 | auto sortedData = DataContainer(nbComponents); | |
27 |
|
27 | |||
28 | for (auto i = 0; i < nbComponents; ++i) { |
|
28 | for (auto i = 0; i < nbComponents; ++i) { | |
29 | sortedData[i] = SortUtils::sort(data.at(i), sortPermutation); |
|
29 | sortedData[i] = SortUtils::sort(data.at(i), sortPermutation); | |
30 | } |
|
30 | } | |
31 |
|
31 | |||
32 | return std::make_shared<ArrayData<Dim> >(std::move(sortedData)); |
|
32 | return std::make_shared<ArrayData<Dim> >(std::move(sortedData)); | |
33 | } |
|
33 | } | |
34 | }; |
|
34 | }; | |
35 |
|
35 | |||
36 | /// Specialization for uni-dimensional ArrayData |
|
36 | /// Specialization for uni-dimensional ArrayData | |
37 | template <> |
|
37 | template <> | |
38 | struct Sort<1> { |
|
38 | struct Sort<1> { | |
39 | static std::shared_ptr<ArrayData<1> > sort(const DataContainer &data, |
|
39 | static std::shared_ptr<ArrayData<1> > sort(const DataContainer &data, | |
40 | const std::vector<int> &sortPermutation) |
|
40 | const std::vector<int> &sortPermutation) | |
41 | { |
|
41 | { | |
42 | return std::make_shared<ArrayData<1> >(SortUtils::sort(data.at(0), sortPermutation)); |
|
42 | return std::make_shared<ArrayData<1> >(SortUtils::sort(data.at(0), sortPermutation)); | |
43 | } |
|
43 | } | |
44 | }; |
|
44 | }; | |
45 |
|
45 | |||
46 | } // namespace arraydata_detail |
|
46 | } // namespace arraydata_detail | |
47 |
|
47 | |||
48 | /** |
|
48 | /** | |
49 | * @brief The ArrayData class represents a dataset for a data series. |
|
49 | * @brief The ArrayData class represents a dataset for a data series. | |
50 | * |
|
50 | * | |
51 | * A dataset can be unidimensional or two-dimensional. This property is determined by the Dim |
|
51 | * A dataset can be unidimensional or two-dimensional. This property is determined by the Dim | |
52 | * template-parameter. In a case of a two-dimensional dataset, each dataset component has the same |
|
52 | * template-parameter. In a case of a two-dimensional dataset, each dataset component has the same | |
53 | * number of values |
|
53 | * number of values | |
54 | * |
|
54 | * | |
55 | * @tparam Dim the dimension of the ArrayData (one or two) |
|
55 | * @tparam Dim the dimension of the ArrayData (one or two) | |
56 | * @sa IDataSeries |
|
56 | * @sa IDataSeries | |
57 | */ |
|
57 | */ | |
58 | template <int Dim> |
|
58 | template <int Dim> | |
59 | class ArrayData { |
|
59 | class ArrayData { | |
60 | public: |
|
60 | public: | |
61 | class IteratorValue { |
|
61 | class IteratorValue { | |
62 | public: |
|
62 | public: | |
63 | explicit IteratorValue(const DataContainer &container, bool begin) : m_Its{} |
|
63 | explicit IteratorValue(const DataContainer &container, bool begin) : m_Its{} | |
64 | { |
|
64 | { | |
65 | for (auto i = 0; i < container.size(); ++i) { |
|
65 | for (auto i = 0; i < container.size(); ++i) { | |
66 | m_Its.push_back(begin ? container.at(i).cbegin() : container.at(i).cend()); |
|
66 | m_Its.push_back(begin ? container.at(i).cbegin() : container.at(i).cend()); | |
67 | } |
|
67 | } | |
68 | } |
|
68 | } | |
69 |
|
69 | |||
70 | double at(int index) const { return *m_Its.at(index); } |
|
70 | double at(int index) const { return *m_Its.at(index); } | |
71 | double first() const { return *m_Its.front(); } |
|
71 | double first() const { return *m_Its.front(); } | |
72 |
|
72 | |||
73 | void next() |
|
73 | void next() | |
74 | { |
|
74 | { | |
75 | for (auto &it : m_Its) { |
|
75 | for (auto &it : m_Its) { | |
76 | ++it; |
|
76 | ++it; | |
77 | } |
|
77 | } | |
78 | } |
|
78 | } | |
79 |
|
79 | |||
80 | bool operator==(const IteratorValue &other) const { return m_Its == other.m_Its; } |
|
80 | bool operator==(const IteratorValue &other) const { return m_Its == other.m_Its; } | |
81 |
|
81 | |||
82 | private: |
|
82 | private: | |
83 | std::vector<DataContainer::value_type::const_iterator> m_Its; |
|
83 | std::vector<DataContainer::value_type::const_iterator> m_Its; | |
84 | }; |
|
84 | }; | |
85 |
|
85 | |||
86 | class Iterator { |
|
86 | class Iterator { | |
87 | public: |
|
87 | public: | |
88 | using iterator_category = std::forward_iterator_tag; |
|
88 | using iterator_category = std::forward_iterator_tag; | |
89 | using value_type = const IteratorValue; |
|
89 | using value_type = const IteratorValue; | |
90 | using difference_type = std::ptrdiff_t; |
|
90 | using difference_type = std::ptrdiff_t; | |
91 | using pointer = value_type *; |
|
91 | using pointer = value_type *; | |
92 | using reference = value_type &; |
|
92 | using reference = value_type &; | |
93 |
|
93 | |||
94 | Iterator(const DataContainer &container, bool begin) : m_CurrentValue{container, begin} {} |
|
94 | Iterator(const DataContainer &container, bool begin) : m_CurrentValue{container, begin} {} | |
95 |
|
95 | |||
96 | virtual ~Iterator() noexcept = default; |
|
96 | virtual ~Iterator() noexcept = default; | |
97 | Iterator(const Iterator &) = default; |
|
97 | Iterator(const Iterator &) = default; | |
98 | Iterator(Iterator &&) = default; |
|
98 | Iterator(Iterator &&) = default; | |
99 | Iterator &operator=(const Iterator &) = default; |
|
99 | Iterator &operator=(const Iterator &) = default; | |
100 | Iterator &operator=(Iterator &&) = default; |
|
100 | Iterator &operator=(Iterator &&) = default; | |
101 |
|
101 | |||
102 | Iterator &operator++() |
|
102 | Iterator &operator++() | |
103 | { |
|
103 | { | |
104 | m_CurrentValue.next(); |
|
104 | m_CurrentValue.next(); | |
105 | return *this; |
|
105 | return *this; | |
106 | } |
|
106 | } | |
107 |
|
107 | |||
108 | pointer operator->() const { return &m_CurrentValue; } |
|
108 | pointer operator->() const { return &m_CurrentValue; } | |
109 | reference operator*() const { return m_CurrentValue; } |
|
109 | reference operator*() const { return m_CurrentValue; } | |
110 |
|
110 | |||
111 | bool operator==(const Iterator &other) const |
|
111 | bool operator==(const Iterator &other) const | |
112 | { |
|
112 | { | |
113 | return m_CurrentValue == other.m_CurrentValue; |
|
113 | return m_CurrentValue == other.m_CurrentValue; | |
114 | } |
|
114 | } | |
115 |
|
115 | |||
116 | bool operator!=(const Iterator &other) const { return !(*this == other); } |
|
116 | bool operator!=(const Iterator &other) const { return !(*this == other); } | |
117 |
|
117 | |||
118 | private: |
|
118 | private: | |
119 | IteratorValue m_CurrentValue; |
|
119 | IteratorValue m_CurrentValue; | |
120 | }; |
|
120 | }; | |
121 |
|
121 | |||
122 | // ///// // |
|
122 | // ///// // | |
123 | // Ctors // |
|
123 | // Ctors // | |
124 | // ///// // |
|
124 | // ///// // | |
125 |
|
125 | |||
126 | /** |
|
126 | /** | |
127 | * Ctor for a unidimensional ArrayData |
|
127 | * Ctor for a unidimensional ArrayData | |
128 | * @param data the data the ArrayData will hold |
|
128 | * @param data the data the ArrayData will hold | |
129 | */ |
|
129 | */ | |
130 | template <int D = Dim, typename = std::enable_if_t<D == 1> > |
|
130 | template <int D = Dim, typename = std::enable_if_t<D == 1> > | |
131 | explicit ArrayData(QVector<double> data) : m_Data{1, QVector<double>{}} |
|
131 | explicit ArrayData(QVector<double> data) : m_Data{1, QVector<double>{}} | |
132 | { |
|
132 | { | |
133 | m_Data[0] = std::move(data); |
|
133 | m_Data[0] = std::move(data); | |
134 | } |
|
134 | } | |
135 |
|
135 | |||
136 | /** |
|
136 | /** | |
137 | * Ctor for a two-dimensional ArrayData. The number of components (number of vectors) must be |
|
137 | * Ctor for a two-dimensional ArrayData. The number of components (number of vectors) must be | |
138 | * greater than 2 and each component must have the same number of values |
|
138 | * greater than 2 and each component must have the same number of values | |
139 | * @param data the data the ArrayData will hold |
|
139 | * @param data the data the ArrayData will hold | |
140 | * @throws std::invalid_argument if the number of components is less than 2 |
|
140 | * @throws std::invalid_argument if the number of components is less than 2 | |
141 | * @remarks if the number of values is not the same for each component, no value is set |
|
141 | * @remarks if the number of values is not the same for each component, no value is set | |
142 | */ |
|
142 | */ | |
143 | template <int D = Dim, typename = std::enable_if_t<D == 2> > |
|
143 | template <int D = Dim, typename = std::enable_if_t<D == 2> > | |
144 | explicit ArrayData(DataContainer data) |
|
144 | explicit ArrayData(DataContainer data) | |
145 | { |
|
145 | { | |
146 | auto nbComponents = data.size(); |
|
146 | auto nbComponents = data.size(); | |
147 | if (nbComponents < 2) { |
|
147 | if (nbComponents < 2) { | |
148 | throw std::invalid_argument{ |
|
148 | throw std::invalid_argument{ | |
149 | QString{"A multidimensional ArrayData must have at least 2 components (found: %1"} |
|
149 | QString{"A multidimensional ArrayData must have at least 2 components (found: %1"} | |
150 | .arg(data.size()) |
|
150 | .arg(data.size()) | |
151 | .toStdString()}; |
|
151 | .toStdString()}; | |
152 | } |
|
152 | } | |
153 |
|
153 | |||
154 | auto nbValues = data.front().size(); |
|
154 | auto nbValues = data.front().size(); | |
155 | if (std::all_of(data.cbegin(), data.cend(), [nbValues](const auto &component) { |
|
155 | if (std::all_of(data.cbegin(), data.cend(), [nbValues](const auto &component) { | |
156 | return component.size() == nbValues; |
|
156 | return component.size() == nbValues; | |
157 | })) { |
|
157 | })) { | |
158 | m_Data = std::move(data); |
|
158 | m_Data = std::move(data); | |
159 | } |
|
159 | } | |
160 | else { |
|
160 | else { | |
161 | m_Data = DataContainer{nbComponents, QVector<double>{}}; |
|
161 | m_Data = DataContainer{nbComponents, QVector<double>{}}; | |
162 | } |
|
162 | } | |
163 | } |
|
163 | } | |
164 |
|
164 | |||
165 | /// Copy ctor |
|
165 | /// Copy ctor | |
166 | explicit ArrayData(const ArrayData &other) |
|
166 | explicit ArrayData(const ArrayData &other) | |
167 | { |
|
167 | { | |
168 | QReadLocker otherLocker{&other.m_Lock}; |
|
168 | QReadLocker otherLocker{&other.m_Lock}; | |
169 | m_Data = other.m_Data; |
|
169 | m_Data = other.m_Data; | |
170 | } |
|
170 | } | |
171 |
|
171 | |||
172 | // /////////////// // |
|
172 | // /////////////// // | |
173 | // General methods // |
|
173 | // General methods // | |
174 | // /////////////// // |
|
174 | // /////////////// // | |
175 |
|
175 | |||
176 | /** |
|
176 | /** | |
177 | * Merges into the array data an other array data. The two array datas must have the same number |
|
177 | * Merges into the array data an other array data. The two array datas must have the same number | |
178 | * of components so the merge can be done |
|
178 | * of components so the merge can be done | |
179 | * @param other the array data to merge with |
|
179 | * @param other the array data to merge with | |
180 | * @param prepend if true, the other array data is inserted at the beginning, otherwise it is |
|
180 | * @param prepend if true, the other array data is inserted at the beginning, otherwise it is | |
181 | * inserted at the end |
|
181 | * inserted at the end | |
182 | */ |
|
182 | */ | |
183 | void add(const ArrayData<Dim> &other, bool prepend = false) |
|
183 | void add(const ArrayData<Dim> &other, bool prepend = false) | |
184 | { |
|
184 | { | |
185 | QWriteLocker locker{&m_Lock}; |
|
185 | QWriteLocker locker{&m_Lock}; | |
186 | QReadLocker otherLocker{&other.m_Lock}; |
|
186 | QReadLocker otherLocker{&other.m_Lock}; | |
187 |
|
187 | |||
188 | auto nbComponents = m_Data.size(); |
|
188 | auto nbComponents = m_Data.size(); | |
189 | if (nbComponents != other.m_Data.size()) { |
|
189 | if (nbComponents != other.m_Data.size()) { | |
190 | return; |
|
190 | return; | |
191 | } |
|
191 | } | |
192 |
|
192 | |||
193 | for (auto componentIndex = 0; componentIndex < nbComponents; ++componentIndex) { |
|
193 | for (auto componentIndex = 0; componentIndex < nbComponents; ++componentIndex) { | |
194 | if (prepend) { |
|
194 | if (prepend) { | |
195 | const auto &otherData = other.data(componentIndex); |
|
195 | const auto &otherData = other.data(componentIndex); | |
196 | const auto otherDataSize = otherData.size(); |
|
196 | const auto otherDataSize = otherData.size(); | |
197 |
|
197 | |||
198 | auto &data = m_Data[componentIndex]; |
|
198 | auto &data = m_Data[componentIndex]; | |
199 | data.insert(data.begin(), otherDataSize, 0.); |
|
199 | data.insert(data.begin(), otherDataSize, 0.); | |
200 |
|
200 | |||
201 | for (auto i = 0; i < otherDataSize; ++i) { |
|
201 | for (auto i = 0; i < otherDataSize; ++i) { | |
202 | data.replace(i, otherData.at(i)); |
|
202 | data.replace(i, otherData.at(i)); | |
203 | } |
|
203 | } | |
204 | } |
|
204 | } | |
205 | else { |
|
205 | else { | |
206 | m_Data[componentIndex] += other.data(componentIndex); |
|
206 | m_Data[componentIndex] += other.data(componentIndex); | |
207 | } |
|
207 | } | |
208 | } |
|
208 | } | |
209 | } |
|
209 | } | |
210 |
|
210 | |||
211 | void clear() |
|
211 | void clear() | |
212 | { |
|
212 | { | |
213 | QWriteLocker locker{&m_Lock}; |
|
213 | QWriteLocker locker{&m_Lock}; | |
214 |
|
214 | |||
215 | auto nbComponents = m_Data.size(); |
|
215 | auto nbComponents = m_Data.size(); | |
216 | for (auto i = 0; i < nbComponents; ++i) { |
|
216 | for (auto i = 0; i < nbComponents; ++i) { | |
217 | m_Data[i].clear(); |
|
217 | m_Data[i].clear(); | |
218 | } |
|
218 | } | |
219 | } |
|
219 | } | |
220 |
|
220 | |||
|
221 | int componentCount() const noexcept { return m_Data.size(); } | |||
|
222 | ||||
221 | /** |
|
223 | /** | |
222 | * @return the data of a component |
|
224 | * @return the data of a component | |
223 | * @param componentIndex the index of the component to retrieve the data |
|
225 | * @param componentIndex the index of the component to retrieve the data | |
224 | * @return the component's data, empty vector if the index is invalid |
|
226 | * @return the component's data, empty vector if the index is invalid | |
225 | */ |
|
227 | */ | |
226 | QVector<double> data(int componentIndex) const noexcept |
|
228 | QVector<double> data(int componentIndex) const noexcept | |
227 | { |
|
229 | { | |
228 | QReadLocker locker{&m_Lock}; |
|
230 | QReadLocker locker{&m_Lock}; | |
229 |
|
231 | |||
230 | return (componentIndex >= 0 && componentIndex < m_Data.size()) ? m_Data.at(componentIndex) |
|
232 | return (componentIndex >= 0 && componentIndex < m_Data.size()) ? m_Data.at(componentIndex) | |
231 | : QVector<double>{}; |
|
233 | : QVector<double>{}; | |
232 | } |
|
234 | } | |
233 |
|
235 | |||
234 | /// @return the size (i.e. number of values) of a single component |
|
236 | /// @return the size (i.e. number of values) of a single component | |
235 | /// @remarks in a case of a two-dimensional ArrayData, each component has the same size |
|
237 | /// @remarks in a case of a two-dimensional ArrayData, each component has the same size | |
236 | int size() const |
|
238 | int size() const | |
237 | { |
|
239 | { | |
238 | QReadLocker locker{&m_Lock}; |
|
240 | QReadLocker locker{&m_Lock}; | |
239 | return m_Data[0].size(); |
|
241 | return m_Data[0].size(); | |
240 | } |
|
242 | } | |
241 |
|
243 | |||
242 | std::shared_ptr<ArrayData<Dim> > sort(const std::vector<int> &sortPermutation) |
|
244 | std::shared_ptr<ArrayData<Dim> > sort(const std::vector<int> &sortPermutation) | |
243 | { |
|
245 | { | |
244 | QReadLocker locker{&m_Lock}; |
|
246 | QReadLocker locker{&m_Lock}; | |
245 | return arraydata_detail::Sort<Dim>::sort(m_Data, sortPermutation); |
|
247 | return arraydata_detail::Sort<Dim>::sort(m_Data, sortPermutation); | |
246 | } |
|
248 | } | |
247 |
|
249 | |||
248 | // ///////// // |
|
250 | // ///////// // | |
249 | // Iterators // |
|
251 | // Iterators // | |
250 | // ///////// // |
|
252 | // ///////// // | |
251 |
|
253 | |||
252 | Iterator cbegin() const { return Iterator{m_Data, true}; } |
|
254 | Iterator cbegin() const { return Iterator{m_Data, true}; } | |
253 | Iterator cend() const { return Iterator{m_Data, false}; } |
|
255 | Iterator cend() const { return Iterator{m_Data, false}; } | |
254 |
|
256 | |||
255 | // ///////////// // |
|
257 | // ///////////// // | |
256 | // 1-dim methods // |
|
258 | // 1-dim methods // | |
257 | // ///////////// // |
|
259 | // ///////////// // | |
258 |
|
260 | |||
259 | /** |
|
261 | /** | |
260 | * @return the data at a specified index |
|
262 | * @return the data at a specified index | |
261 | * @remarks index must be a valid position |
|
263 | * @remarks index must be a valid position | |
262 | * @remarks this method is only available for a unidimensional ArrayData |
|
264 | * @remarks this method is only available for a unidimensional ArrayData | |
263 | */ |
|
265 | */ | |
264 | template <int D = Dim, typename = std::enable_if_t<D == 1> > |
|
266 | template <int D = Dim, typename = std::enable_if_t<D == 1> > | |
265 | double at(int index) const noexcept |
|
267 | double at(int index) const noexcept | |
266 | { |
|
268 | { | |
267 | QReadLocker locker{&m_Lock}; |
|
269 | QReadLocker locker{&m_Lock}; | |
268 | return m_Data[0].at(index); |
|
270 | return m_Data[0].at(index); | |
269 | } |
|
271 | } | |
270 |
|
272 | |||
271 | /** |
|
273 | /** | |
272 | * @return the data as a vector, as a const reference |
|
274 | * @return the data as a vector, as a const reference | |
273 | * @remarks this method is only available for a unidimensional ArrayData |
|
275 | * @remarks this method is only available for a unidimensional ArrayData | |
274 | */ |
|
276 | */ | |
275 | template <int D = Dim, typename = std::enable_if_t<D == 1> > |
|
277 | template <int D = Dim, typename = std::enable_if_t<D == 1> > | |
276 | const QVector<double> &cdata() const noexcept |
|
278 | const QVector<double> &cdata() const noexcept | |
277 | { |
|
279 | { | |
278 | QReadLocker locker{&m_Lock}; |
|
280 | QReadLocker locker{&m_Lock}; | |
279 | return m_Data.at(0); |
|
281 | return m_Data.at(0); | |
280 | } |
|
282 | } | |
281 |
|
283 | |||
282 | /** |
|
284 | /** | |
283 | * @return the data as a vector |
|
285 | * @return the data as a vector | |
284 | * @remarks this method is only available for a unidimensional ArrayData |
|
286 | * @remarks this method is only available for a unidimensional ArrayData | |
285 | */ |
|
287 | */ | |
286 | template <int D = Dim, typename = std::enable_if_t<D == 1> > |
|
288 | template <int D = Dim, typename = std::enable_if_t<D == 1> > | |
287 | QVector<double> data() const noexcept |
|
289 | QVector<double> data() const noexcept | |
288 | { |
|
290 | { | |
289 | QReadLocker locker{&m_Lock}; |
|
291 | QReadLocker locker{&m_Lock}; | |
290 | return m_Data[0]; |
|
292 | return m_Data[0]; | |
291 | } |
|
293 | } | |
292 |
|
294 | |||
293 | // ///////////// // |
|
295 | // ///////////// // | |
294 | // 2-dim methods // |
|
296 | // 2-dim methods // | |
295 | // ///////////// // |
|
297 | // ///////////// // | |
296 |
|
298 | |||
297 | /** |
|
299 | /** | |
298 | * @return the data |
|
300 | * @return the data | |
299 | * @remarks this method is only available for a two-dimensional ArrayData |
|
301 | * @remarks this method is only available for a two-dimensional ArrayData | |
300 | */ |
|
302 | */ | |
301 | template <int D = Dim, typename = std::enable_if_t<D == 2> > |
|
303 | template <int D = Dim, typename = std::enable_if_t<D == 2> > | |
302 | DataContainer data() const noexcept |
|
304 | DataContainer data() const noexcept | |
303 | { |
|
305 | { | |
304 | QReadLocker locker{&m_Lock}; |
|
306 | QReadLocker locker{&m_Lock}; | |
305 | return m_Data; |
|
307 | return m_Data; | |
306 | } |
|
308 | } | |
307 |
|
309 | |||
308 | private: |
|
310 | private: | |
309 | DataContainer m_Data; |
|
311 | DataContainer m_Data; | |
310 | mutable QReadWriteLock m_Lock; |
|
312 | mutable QReadWriteLock m_Lock; | |
311 | }; |
|
313 | }; | |
312 |
|
314 | |||
313 | #endif // SCIQLOP_ARRAYDATA_H |
|
315 | #endif // SCIQLOP_ARRAYDATA_H |
@@ -1,40 +1,39 | |||||
1 | #ifndef SCIQLOP_VISUALIZATIONGRAPHHELPER_H |
|
1 | #ifndef SCIQLOP_VISUALIZATIONGRAPHHELPER_H | |
2 | #define SCIQLOP_VISUALIZATIONGRAPHHELPER_H |
|
2 | #define SCIQLOP_VISUALIZATIONGRAPHHELPER_H | |
3 |
|
3 | |||
|
4 | #include "Visualization/VisualizationDefs.h" | |||
|
5 | ||||
4 | #include <Data/SqpRange.h> |
|
6 | #include <Data/SqpRange.h> | |
5 |
|
7 | |||
6 | #include <QLoggingCategory> |
|
8 | #include <QLoggingCategory> | |
7 | #include <QVector> |
|
9 | #include <QVector> | |
8 |
|
10 | |||
9 | #include <memory> |
|
11 | #include <memory> | |
10 |
|
12 | |||
11 | Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphHelper) |
|
13 | Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphHelper) | |
12 |
|
14 | |||
13 | class IDataSeries; |
|
15 | class IDataSeries; | |
14 | class QCPAbstractPlottable; |
|
16 | class QCPAbstractPlottable; | |
15 | class QCustomPlot; |
|
17 | class QCustomPlot; | |
16 | class Variable; |
|
18 | class Variable; | |
17 |
|
19 | |||
18 | /** |
|
20 | /** | |
19 | * @brief The VisualizationGraphHelper class aims to create the QCustomPlot components relative to a |
|
21 | * @brief The VisualizationGraphHelper class aims to create the QCustomPlot components relative to a | |
20 | * variable, depending on the data series of this variable |
|
22 | * variable, depending on the data series of this variable | |
21 | */ |
|
23 | */ | |
22 | struct VisualizationGraphHelper { |
|
24 | struct VisualizationGraphHelper { | |
23 | /** |
|
25 | /** | |
24 | * Creates (if possible) the QCustomPlot components relative to the variable passed in |
|
26 | * Creates (if possible) the QCustomPlot components relative to the variable passed in | |
25 | * parameter, and adds these to the plot passed in parameter. |
|
27 | * parameter, and adds these to the plot passed in parameter. | |
26 | * @param variable the variable for which to create the components |
|
28 | * @param variable the variable for which to create the components | |
27 | * @param plot the plot in which to add the created components. It takes ownership of these |
|
29 | * @param plot the plot in which to add the created components. It takes ownership of these | |
28 | * components. |
|
30 | * components. | |
29 | * @return the list of the components created |
|
31 | * @return the list of the components created | |
30 | */ |
|
32 | */ | |
31 |
static |
|
33 | static PlottablesMap create(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept; | |
32 | QCustomPlot &plot) noexcept; |
|
|||
33 | static QVector<QCPAbstractPlottable *> createV2(std::shared_ptr<Variable> variable, |
|
|||
34 | QCustomPlot &plot) noexcept; |
|
|||
35 |
|
34 | |||
36 |
static void updateData( |
|
35 | static void updateData(PlottablesMap &plottables, IDataSeries *dataSeries, | |
37 |
|
|
36 | const SqpRange &dateTime); | |
38 | }; |
|
37 | }; | |
39 |
|
38 | |||
40 | #endif // SCIQLOP_VISUALIZATIONGRAPHHELPER_H |
|
39 | #endif // SCIQLOP_VISUALIZATIONGRAPHHELPER_H |
@@ -1,195 +1,239 | |||||
1 | #include "Visualization/VisualizationGraphHelper.h" |
|
1 | #include "Visualization/VisualizationGraphHelper.h" | |
2 | #include "Visualization/qcustomplot.h" |
|
2 | #include "Visualization/qcustomplot.h" | |
3 |
|
3 | |||
|
4 | #include <Common/ColorUtils.h> | |||
|
5 | ||||
4 | #include <Data/ScalarSeries.h> |
|
6 | #include <Data/ScalarSeries.h> | |
|
7 | #include <Data/VectorSeries.h> | |||
5 |
|
8 | |||
6 | #include <Variable/Variable.h> |
|
9 | #include <Variable/Variable.h> | |
7 |
|
10 | |||
8 | Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper") |
|
11 | Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper") | |
9 |
|
12 | |||
10 | namespace { |
|
13 | namespace { | |
11 |
|
14 | |||
12 | class SqpDataContainer : public QCPGraphDataContainer { |
|
15 | class SqpDataContainer : public QCPGraphDataContainer { | |
13 | public: |
|
16 | public: | |
14 | void appendGraphData(const QCPGraphData &data) { mData.append(data); } |
|
17 | void appendGraphData(const QCPGraphData &data) { mData.append(data); } | |
15 | }; |
|
18 | }; | |
16 |
|
19 | |||
17 |
|
20 | |||
18 | /// Format for datetimes on a axis |
|
21 | /// Format for datetimes on a axis | |
19 | const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss"); |
|
22 | const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss"); | |
20 |
|
23 | |||
21 | /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or |
|
24 | /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or | |
22 | /// non-time data |
|
25 | /// non-time data | |
23 | QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis) |
|
26 | QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis) | |
24 | { |
|
27 | { | |
25 | if (isTimeAxis) { |
|
28 | if (isTimeAxis) { | |
26 | auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create(); |
|
29 | auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create(); | |
27 | dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT); |
|
30 | dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT); | |
28 | dateTicker->setDateTimeSpec(Qt::UTC); |
|
31 | dateTicker->setDateTimeSpec(Qt::UTC); | |
29 |
|
32 | |||
30 | return dateTicker; |
|
33 | return dateTicker; | |
31 | } |
|
34 | } | |
32 | else { |
|
35 | else { | |
33 | // default ticker |
|
36 | // default ticker | |
34 | return QSharedPointer<QCPAxisTicker>::create(); |
|
37 | return QSharedPointer<QCPAxisTicker>::create(); | |
35 | } |
|
38 | } | |
36 | } |
|
39 | } | |
37 |
|
40 | |||
38 | void updateScalarData(QCPAbstractPlottable *component, std::shared_ptr<ScalarSeries> scalarSeries, |
|
41 | /// Sets axes properties according to the properties of a data series | |
39 | const SqpRange &range) |
|
42 | template <int Dim> | |
40 | { |
|
43 | void setAxesProperties(const DataSeries<Dim> &dataSeries, QCustomPlot &plot) noexcept | |
41 | qCDebug(LOG_VisualizationGraphHelper()) << "TORM: updateScalarData" |
|
|||
42 | << QThread::currentThread()->objectName(); |
|
|||
43 | if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) { |
|
|||
44 | scalarSeries->lockRead(); |
|
|||
45 | { |
|
44 | { | |
46 | auto sqpDataContainer = QSharedPointer<SqpDataContainer>::create(); |
|
|||
47 | qcpGraph->setData(sqpDataContainer); |
|
|||
48 | auto bounds = scalarSeries->subData(range.m_TStart, range.m_TEnd); |
|
|||
49 | for (auto it = bounds.first; it != bounds.second; ++it) { |
|
|||
50 | sqpDataContainer->appendGraphData(QCPGraphData(it->x(), it->value())); |
|
|||
51 | } |
|
|||
52 |
|
||||
53 | qCInfo(LOG_VisualizationGraphHelper()) << "TODEBUG: Current points displayed" |
|
|||
54 | << sqpDataContainer->size(); |
|
|||
55 | } |
|
|||
56 | scalarSeries->unlock(); |
|
|||
57 |
|
||||
58 |
|
||||
59 | // Display all data |
|
|||
60 | component->parentPlot()->replot(); |
|
|||
61 | } |
|
|||
62 | else { |
|
|||
63 | /// @todo DEBUG |
|
|||
64 | } |
|
|||
65 | } |
|
|||
66 |
|
||||
67 | QCPAbstractPlottable *createScalarSeriesComponentV2(std::shared_ptr<ScalarSeries> scalarSeries, |
|
|||
68 | QCustomPlot &plot) |
|
|||
69 | { |
|
|||
70 | auto component = plot.addGraph(); |
|
|||
71 |
|
||||
72 | if (component) { |
|
|||
73 | // Axes properties |
|
|||
74 |
|
|
45 | /// @todo : for the moment, no control is performed on the axes: the units and the tickers | |
75 |
|
|
46 | /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph | |
76 |
|
||||
77 |
|
|
47 | auto setAxisProperties = [](auto axis, const auto &unit) { | |
78 |
|
|
48 | // label (unit name) | |
79 |
|
|
49 | axis->setLabel(unit.m_Name); | |
80 |
|
50 | |||
81 |
|
|
51 | // ticker (depending on the type of unit) | |
82 |
|
|
52 | axis->setTicker(axisTicker(unit.m_TimeUnit)); | |
83 |
|
|
53 | }; | |
84 |
|
|
54 | setAxisProperties(plot.xAxis, dataSeries.xAxisUnit()); | |
85 |
|
|
55 | setAxisProperties(plot.yAxis, dataSeries.valuesUnit()); | |
86 | } |
|
56 | } | |
87 | return component; |
|
57 | ||
|
58 | /** | |||
|
59 | * Struct used to create plottables, depending on the type of the data series from which to create them | |||
|
60 | * @tparam T the data series' type | |||
|
61 | * @remarks Default implementation can't create plottables | |||
|
62 | */ | |||
|
63 | template <typename T, typename Enabled = void> | |||
|
64 | struct PlottablesCreator { | |||
|
65 | static PlottablesMap createPlottables(T &, QCustomPlot &) | |||
|
66 | { | |||
|
67 | qCCritical(LOG_DataSeries()) | |||
|
68 | << QObject::tr("Can't create plottables: unmanaged data series type"); | |||
|
69 | return {}; | |||
88 | } |
|
70 | } | |
|
71 | }; | |||
89 |
|
72 | |||
90 | QCPAbstractPlottable *createScalarSeriesComponent(std::shared_ptr<ScalarSeries> scalarSeries, |
|
73 | /** | |
91 | QCustomPlot &plot, const SqpRange &dateTime) |
|
74 | * Specialization of PlottablesCreator for scalars and vectors | |
|
75 | * @sa ScalarSeries | |||
|
76 | * @sa VectorSeries | |||
|
77 | */ | |||
|
78 | template <typename T> | |||
|
79 | struct PlottablesCreator<T, | |||
|
80 | typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value | |||
|
81 | or std::is_base_of<VectorSeries, T>::value> > { | |||
|
82 | static PlottablesMap createPlottables(T &dataSeries, QCustomPlot &plot) | |||
92 | { |
|
83 | { | |
93 | auto component = plot.addGraph(); |
|
84 | PlottablesMap result{}; | |
94 |
|
85 | |||
95 | if (component) { |
|
86 | // Gets the number of components of the data series | |
96 | // // Graph data |
|
87 | auto componentCount = dataSeries.valuesData()->componentCount(); | |
97 | component->setData(scalarSeries->xAxisData()->data(), scalarSeries->valuesData()->data(), |
|
|||
98 | true); |
|
|||
99 |
|
88 | |||
100 | updateScalarData(component, scalarSeries, dateTime); |
|
89 | auto colors = ColorUtils::colors(Qt::blue, Qt::red, componentCount); | |
|
90 | ||||
|
91 | // For each component of the data series, creates a QCPGraph to add to the plot | |||
|
92 | for (auto i = 0; i < componentCount; ++i) { | |||
|
93 | auto graph = plot.addGraph(); | |||
|
94 | graph->setPen(QPen{colors.at(i)}); | |||
|
95 | ||||
|
96 | result.insert({i, graph}); | |||
|
97 | } | |||
101 |
|
98 | |||
102 | // Axes properties |
|
99 | // Axes properties | |
103 | /// @todo : for the moment, no control is performed on the axes: the units and the tickers |
|
100 | setAxesProperties(dataSeries, plot); | |
104 | /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph |
|
|||
105 |
|
101 | |||
106 | auto setAxisProperties = [](auto axis, const auto &unit) { |
|
102 | plot.replot(); | |
107 | // label (unit name) |
|
|||
108 | axis->setLabel(unit.m_Name); |
|
|||
109 |
|
103 | |||
110 | // ticker (depending on the type of unit) |
|
104 | return result; | |
111 | axis->setTicker(axisTicker(unit.m_TimeUnit)); |
|
105 | } | |
112 | }; |
|
106 | }; | |
113 | setAxisProperties(plot.xAxis, scalarSeries->xAxisUnit()); |
|
|||
114 | setAxisProperties(plot.yAxis, scalarSeries->valuesUnit()); |
|
|||
115 |
|
107 | |||
116 | // Display all data |
|
108 | /** | |
117 | component->rescaleAxes(); |
|
109 | * Struct used to update plottables, depending on the type of the data series from which to update them | |
118 | plot.replot(); |
|
110 | * @tparam T the data series' type | |
|
111 | * @remarks Default implementation can't update plottables | |||
|
112 | */ | |||
|
113 | template <typename T, typename Enabled = void> | |||
|
114 | struct PlottablesUpdater { | |||
|
115 | static void updatePlottables(T &, PlottablesMap &, const SqpRange &, bool) | |||
|
116 | { | |||
|
117 | qCCritical(LOG_DataSeries()) | |||
|
118 | << QObject::tr("Can't update plottables: unmanaged data series type"); | |||
|
119 | } | |||
|
120 | }; | |||
|
121 | ||||
|
122 | /** | |||
|
123 | * Specialization of PlottablesUpdater for scalars and vectors | |||
|
124 | * @sa ScalarSeries | |||
|
125 | * @sa VectorSeries | |||
|
126 | */ | |||
|
127 | template <typename T> | |||
|
128 | struct PlottablesUpdater<T, | |||
|
129 | typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value | |||
|
130 | or std::is_base_of<VectorSeries, T>::value> > { | |||
|
131 | static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const SqpRange &range, | |||
|
132 | bool rescaleAxes) | |||
|
133 | { | |||
|
134 | dataSeries.lockRead(); | |||
|
135 | ||||
|
136 | // For each plottable to update, resets its data | |||
|
137 | std::map<int, QSharedPointer<SqpDataContainer> > dataContainers{}; | |||
|
138 | for (const auto &plottable : plottables) { | |||
|
139 | if (auto graph = dynamic_cast<QCPGraph *>(plottable.second)) { | |||
|
140 | auto dataContainer = QSharedPointer<SqpDataContainer>::create(); | |||
|
141 | graph->setData(dataContainer); | |||
|
142 | ||||
|
143 | dataContainers.insert({plottable.first, dataContainer}); | |||
119 | } |
|
144 | } | |
120 | else { |
|
|||
121 | qCDebug(LOG_VisualizationGraphHelper()) |
|
|||
122 | << QObject::tr("Can't create graph for the scalar series"); |
|
|||
123 | } |
|
145 | } | |
124 |
|
146 | |||
125 | return component; |
|
147 | // - Gets the data of the series included in the current range | |
|
148 | // - Updates each plottable by adding, for each data item, a point that takes x-axis data and value data. The correct value is retrieved according to the index of the component | |||
|
149 | auto subDataIts = dataSeries.subData(range.m_TStart, range.m_TEnd); | |||
|
150 | for (auto it = subDataIts.first; it != subDataIts.second; ++it) { | |||
|
151 | for (const auto &dataContainer : dataContainers) { | |||
|
152 | auto componentIndex = dataContainer.first; | |||
|
153 | dataContainer.second->appendGraphData( | |||
|
154 | QCPGraphData(it->x(), it->value(componentIndex))); | |||
|
155 | } | |||
126 | } |
|
156 | } | |
127 |
|
157 | |||
128 | } // namespace |
|
158 | dataSeries.unlock(); | |
129 |
|
159 | |||
130 | QVector<QCPAbstractPlottable *> |
|
160 | if (!plottables.empty()) { | |
131 | VisualizationGraphHelper::createV2(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept |
|
161 | auto plot = plottables.begin()->second->parentPlot(); | |
132 | { |
|
|||
133 | auto result = QVector<QCPAbstractPlottable *>{}; |
|
|||
134 |
|
162 | |||
135 | if (variable) { |
|
163 | if (rescaleAxes) { | |
136 | // Gets the data series of the variable to call the creation of the right components |
|
164 | plot->rescaleAxes(); | |
137 | // according to its type |
|
|||
138 | if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(variable->dataSeries())) { |
|
|||
139 | result.append(createScalarSeriesComponentV2(scalarSeries, plot)); |
|
|||
140 | } |
|
165 | } | |
141 | else { |
|
166 | ||
142 | qCDebug(LOG_VisualizationGraphHelper()) |
|
167 | plot->replot(); | |
143 | << QObject::tr("Can't create graph plottables : unmanaged data series type"); |
|
|||
144 | } |
|
168 | } | |
145 | } |
|
169 | } | |
146 | else { |
|
170 | }; | |
147 | qCDebug(LOG_VisualizationGraphHelper()) |
|
|||
148 | << QObject::tr("Can't create graph plottables : the variable is null"); |
|
|||
149 | } |
|
|||
150 |
|
171 | |||
151 | return result; |
|
172 | /** | |
|
173 | * Helper used to create/update plottables | |||
|
174 | */ | |||
|
175 | struct IPlottablesHelper { | |||
|
176 | virtual ~IPlottablesHelper() noexcept = default; | |||
|
177 | virtual PlottablesMap create(QCustomPlot &plot) const = 0; | |||
|
178 | virtual void update(PlottablesMap &plottables, const SqpRange &range, | |||
|
179 | bool rescaleAxes = false) const = 0; | |||
|
180 | }; | |||
|
181 | ||||
|
182 | /** | |||
|
183 | * Default implementation of IPlottablesHelper, which takes data series to create/update plottables | |||
|
184 | * @tparam T the data series' type | |||
|
185 | */ | |||
|
186 | template <typename T> | |||
|
187 | struct PlottablesHelper : public IPlottablesHelper { | |||
|
188 | explicit PlottablesHelper(T &dataSeries) : m_DataSeries{dataSeries} {} | |||
|
189 | ||||
|
190 | PlottablesMap create(QCustomPlot &plot) const override | |||
|
191 | { | |||
|
192 | return PlottablesCreator<T>::createPlottables(m_DataSeries, plot); | |||
152 | } |
|
193 | } | |
153 |
|
194 | |||
154 | QVector<QCPAbstractPlottable *> VisualizationGraphHelper::create(std::shared_ptr<Variable> variable, |
|
195 | void update(PlottablesMap &plottables, const SqpRange &range, bool rescaleAxes) const override | |
155 | QCustomPlot &plot) noexcept |
|
|||
156 | { |
|
196 | { | |
157 | auto result = QVector<QCPAbstractPlottable *>{}; |
|
197 | PlottablesUpdater<T>::updatePlottables(m_DataSeries, plottables, range, rescaleAxes); | |
|
198 | } | |||
158 |
|
199 | |||
159 | if (variable) { |
|
200 | T &m_DataSeries; | |
160 | // Gets the data series of the variable to call the creation of the right components |
|
201 | }; | |
161 | // according to its type |
|
202 | ||
162 | if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(variable->dataSeries())) { |
|
203 | /// Creates IPlottablesHelper according to a data series | |
163 | result.append(createScalarSeriesComponent(scalarSeries, plot, variable->range())); |
|
204 | std::unique_ptr<IPlottablesHelper> createHelper(IDataSeries *dataSeries) noexcept | |
|
205 | { | |||
|
206 | if (auto scalarSeries = dynamic_cast<ScalarSeries *>(dataSeries)) { | |||
|
207 | return std::make_unique<PlottablesHelper<ScalarSeries> >(*scalarSeries); | |||
|
208 | } | |||
|
209 | else if (auto vectorSeries = dynamic_cast<VectorSeries *>(dataSeries)) { | |||
|
210 | return std::make_unique<PlottablesHelper<VectorSeries> >(*vectorSeries); | |||
164 |
|
|
211 | } | |
165 |
|
|
212 | else { | |
166 | qCDebug(LOG_VisualizationGraphHelper()) |
|
213 | return std::make_unique<PlottablesHelper<IDataSeries> >(*dataSeries); | |
167 | << QObject::tr("Can't create graph plottables : unmanaged data series type"); |
|
|||
168 |
|
|
214 | } | |
169 | } |
|
215 | } | |
|
216 | ||||
|
217 | } // namespace | |||
|
218 | ||||
|
219 | PlottablesMap VisualizationGraphHelper::create(std::shared_ptr<Variable> variable, | |||
|
220 | QCustomPlot &plot) noexcept | |||
|
221 | { | |||
|
222 | if (variable) { | |||
|
223 | auto helper = createHelper(variable->dataSeries().get()); | |||
|
224 | auto plottables = helper->create(plot); | |||
|
225 | return plottables; | |||
|
226 | } | |||
170 | else { |
|
227 | else { | |
171 | qCDebug(LOG_VisualizationGraphHelper()) |
|
228 | qCDebug(LOG_VisualizationGraphHelper()) | |
172 | << QObject::tr("Can't create graph plottables : the variable is null"); |
|
229 | << QObject::tr("Can't create graph plottables : the variable is null"); | |
|
230 | return PlottablesMap{}; | |||
173 | } |
|
231 | } | |
174 |
|
||||
175 | return result; |
|
|||
176 | } |
|
232 | } | |
177 |
|
233 | |||
178 |
void VisualizationGraphHelper::updateData( |
|
234 | void VisualizationGraphHelper::updateData(PlottablesMap &plottables, IDataSeries *dataSeries, | |
179 | std::shared_ptr<IDataSeries> dataSeries, |
|
|||
180 | const SqpRange &dateTime) |
|
235 | const SqpRange &dateTime) | |
181 | { |
|
236 | { | |
182 | if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) { |
|
237 | auto helper = createHelper(dataSeries); | |
183 | if (plotableVect.size() == 1) { |
|
238 | helper->update(plottables, dateTime); | |
184 | updateScalarData(plotableVect.at(0), scalarSeries, dateTime); |
|
|||
185 | } |
|
|||
186 | else { |
|
|||
187 | qCCritical(LOG_VisualizationGraphHelper()) << QObject::tr( |
|
|||
188 | "Can't update Data of a scalarSeries because there is not only one component " |
|
|||
189 | "associated"); |
|
|||
190 | } |
|
|||
191 | } |
|
|||
192 | else { |
|
|||
193 | /// @todo DEBUG |
|
|||
194 | } |
|
|||
195 | } |
|
239 | } |
@@ -1,320 +1,313 | |||||
1 | #include "Visualization/VisualizationGraphWidget.h" |
|
1 | #include "Visualization/VisualizationGraphWidget.h" | |
2 | #include "Visualization/IVisualizationWidgetVisitor.h" |
|
2 | #include "Visualization/IVisualizationWidgetVisitor.h" | |
|
3 | #include "Visualization/VisualizationDefs.h" | |||
3 | #include "Visualization/VisualizationGraphHelper.h" |
|
4 | #include "Visualization/VisualizationGraphHelper.h" | |
4 | #include "Visualization/VisualizationGraphRenderingDelegate.h" |
|
5 | #include "Visualization/VisualizationGraphRenderingDelegate.h" | |
5 | #include "ui_VisualizationGraphWidget.h" |
|
6 | #include "ui_VisualizationGraphWidget.h" | |
6 |
|
7 | |||
7 | #include <Data/ArrayData.h> |
|
8 | #include <Data/ArrayData.h> | |
8 | #include <Data/IDataSeries.h> |
|
9 | #include <Data/IDataSeries.h> | |
9 | #include <Settings/SqpSettingsDefs.h> |
|
10 | #include <Settings/SqpSettingsDefs.h> | |
10 | #include <SqpApplication.h> |
|
11 | #include <SqpApplication.h> | |
11 | #include <Variable/Variable.h> |
|
12 | #include <Variable/Variable.h> | |
12 | #include <Variable/VariableController.h> |
|
13 | #include <Variable/VariableController.h> | |
13 |
|
14 | |||
14 | #include <unordered_map> |
|
15 | #include <unordered_map> | |
15 |
|
16 | |||
16 | Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget") |
|
17 | Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget") | |
17 |
|
18 | |||
18 | namespace { |
|
19 | namespace { | |
19 |
|
20 | |||
20 | /// Key pressed to enable zoom on horizontal axis |
|
21 | /// Key pressed to enable zoom on horizontal axis | |
21 | const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier; |
|
22 | const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier; | |
22 |
|
23 | |||
23 | /// Key pressed to enable zoom on vertical axis |
|
24 | /// Key pressed to enable zoom on vertical axis | |
24 | const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier; |
|
25 | const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier; | |
25 |
|
26 | |||
26 | } // namespace |
|
27 | } // namespace | |
27 |
|
28 | |||
28 | struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate { |
|
29 | struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate { | |
29 |
|
30 | |||
30 | explicit VisualizationGraphWidgetPrivate() |
|
31 | explicit VisualizationGraphWidgetPrivate() | |
31 | : m_DoAcquisition{true}, m_IsCalibration{false}, m_RenderingDelegate{nullptr} |
|
32 | : m_DoAcquisition{true}, m_IsCalibration{false}, m_RenderingDelegate{nullptr} | |
32 | { |
|
33 | { | |
33 | } |
|
34 | } | |
34 |
|
35 | |||
35 | // 1 variable -> n qcpplot |
|
36 | // 1 variable -> n qcpplot | |
36 |
std:: |
|
37 | std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap; | |
37 | bool m_DoAcquisition; |
|
38 | bool m_DoAcquisition; | |
38 | bool m_IsCalibration; |
|
39 | bool m_IsCalibration; | |
39 | QCPItemTracer *m_TextTracer; |
|
40 | QCPItemTracer *m_TextTracer; | |
40 | /// Delegate used to attach rendering features to the plot |
|
41 | /// Delegate used to attach rendering features to the plot | |
41 | std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate; |
|
42 | std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate; | |
42 | }; |
|
43 | }; | |
43 |
|
44 | |||
44 | VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent) |
|
45 | VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent) | |
45 | : QWidget{parent}, |
|
46 | : QWidget{parent}, | |
46 | ui{new Ui::VisualizationGraphWidget}, |
|
47 | ui{new Ui::VisualizationGraphWidget}, | |
47 | impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()} |
|
48 | impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()} | |
48 | { |
|
49 | { | |
49 | ui->setupUi(this); |
|
50 | ui->setupUi(this); | |
50 |
|
51 | |||
51 | // The delegate must be initialized after the ui as it uses the plot |
|
52 | // The delegate must be initialized after the ui as it uses the plot | |
52 | impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*ui->widget); |
|
53 | impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*ui->widget); | |
53 |
|
54 | |||
54 | ui->graphNameLabel->setText(name); |
|
55 | ui->graphNameLabel->setText(name); | |
55 |
|
56 | |||
56 | // 'Close' options : widget is deleted when closed |
|
57 | // 'Close' options : widget is deleted when closed | |
57 | setAttribute(Qt::WA_DeleteOnClose); |
|
58 | setAttribute(Qt::WA_DeleteOnClose); | |
58 | connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationGraphWidget::close); |
|
59 | connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationGraphWidget::close); | |
59 | ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton)); |
|
60 | ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton)); | |
60 |
|
61 | |||
61 | // Set qcpplot properties : |
|
62 | // Set qcpplot properties : | |
62 | // - Drag (on x-axis) and zoom are enabled |
|
63 | // - Drag (on x-axis) and zoom are enabled | |
63 | // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation |
|
64 | // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation | |
64 | ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom); |
|
65 | ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom); | |
65 | ui->widget->axisRect()->setRangeDrag(Qt::Horizontal); |
|
66 | ui->widget->axisRect()->setRangeDrag(Qt::Horizontal); | |
66 |
|
67 | |||
67 | connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress); |
|
68 | connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress); | |
68 | connect(ui->widget, &QCustomPlot::mouseRelease, this, |
|
69 | connect(ui->widget, &QCustomPlot::mouseRelease, this, | |
69 | &VisualizationGraphWidget::onMouseRelease); |
|
70 | &VisualizationGraphWidget::onMouseRelease); | |
70 | connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove); |
|
71 | connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove); | |
71 | connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel); |
|
72 | connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel); | |
72 | connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>( |
|
73 | connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>( | |
73 | &QCPAxis::rangeChanged), |
|
74 | &QCPAxis::rangeChanged), | |
74 | this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection); |
|
75 | this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection); | |
75 |
|
76 | |||
76 | // Activates menu when right clicking on the graph |
|
77 | // Activates menu when right clicking on the graph | |
77 | ui->widget->setContextMenuPolicy(Qt::CustomContextMenu); |
|
78 | ui->widget->setContextMenuPolicy(Qt::CustomContextMenu); | |
78 | connect(ui->widget, &QCustomPlot::customContextMenuRequested, this, |
|
79 | connect(ui->widget, &QCustomPlot::customContextMenuRequested, this, | |
79 | &VisualizationGraphWidget::onGraphMenuRequested); |
|
80 | &VisualizationGraphWidget::onGraphMenuRequested); | |
80 |
|
81 | |||
81 | connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(), |
|
82 | connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(), | |
82 | &VariableController::onRequestDataLoading); |
|
83 | &VariableController::onRequestDataLoading); | |
83 |
|
84 | |||
84 | connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this, |
|
85 | connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this, | |
85 | &VisualizationGraphWidget::onUpdateVarDisplaying); |
|
86 | &VisualizationGraphWidget::onUpdateVarDisplaying); | |
86 | } |
|
87 | } | |
87 |
|
88 | |||
88 |
|
89 | |||
89 | VisualizationGraphWidget::~VisualizationGraphWidget() |
|
90 | VisualizationGraphWidget::~VisualizationGraphWidget() | |
90 | { |
|
91 | { | |
91 | delete ui; |
|
92 | delete ui; | |
92 | } |
|
93 | } | |
93 |
|
94 | |||
94 | void VisualizationGraphWidget::enableAcquisition(bool enable) |
|
95 | void VisualizationGraphWidget::enableAcquisition(bool enable) | |
95 | { |
|
96 | { | |
96 | impl->m_DoAcquisition = enable; |
|
97 | impl->m_DoAcquisition = enable; | |
97 | } |
|
98 | } | |
98 |
|
99 | |||
99 | void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range) |
|
100 | void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range) | |
100 | { |
|
101 | { | |
101 | // Uses delegate to create the qcpplot components according to the variable |
|
102 | // Uses delegate to create the qcpplot components according to the variable | |
102 |
auto createdPlottables = VisualizationGraphHelper::create |
|
103 | auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget); | |
103 |
|
104 | impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)}); | ||
104 | for (auto createdPlottable : qAsConst(createdPlottables)) { |
|
|||
105 | impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable}); |
|
|||
106 | } |
|
|||
107 |
|
105 | |||
108 | connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated())); |
|
106 | connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated())); | |
109 |
|
107 | |||
110 | auto varRange = variable->range(); |
|
108 | auto varRange = variable->range(); | |
111 |
|
109 | |||
112 | this->enableAcquisition(false); |
|
110 | this->enableAcquisition(false); | |
113 | this->setGraphRange(range); |
|
111 | this->setGraphRange(range); | |
114 | this->enableAcquisition(true); |
|
112 | this->enableAcquisition(true); | |
115 |
|
113 | |||
116 | emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, varRange, |
|
114 | emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, varRange, | |
117 | false); |
|
115 | false); | |
118 |
|
116 | |||
119 | emit variableAdded(variable); |
|
117 | emit variableAdded(variable); | |
120 | } |
|
118 | } | |
121 |
|
119 | |||
122 | void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept |
|
120 | void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept | |
123 | { |
|
121 | { | |
124 | // Each component associated to the variable : |
|
122 | // Each component associated to the variable : | |
125 | // - is removed from qcpplot (which deletes it) |
|
123 | // - is removed from qcpplot (which deletes it) | |
126 | // - is no longer referenced in the map |
|
124 | // - is no longer referenced in the map | |
127 |
auto |
|
125 | auto variableIt = impl->m_VariableToPlotMultiMap.find(variable); | |
128 | for (auto it = componentsIt.first; it != componentsIt.second;) { |
|
126 | if (variableIt != impl->m_VariableToPlotMultiMap.cend()) { | |
129 |
|
|
127 | auto &plottablesMap = variableIt->second; | |
130 | it = impl->m_VariableToPlotMultiMap.erase(it); |
|
128 | ||
|
129 | for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend(); | |||
|
130 | plottableIt != plottableEnd;) { | |||
|
131 | ui->widget->removePlottable(plottableIt->second); | |||
|
132 | plottableIt = plottablesMap.erase(plottableIt); | |||
|
133 | } | |||
|
134 | ||||
|
135 | impl->m_VariableToPlotMultiMap.erase(variableIt); | |||
131 | } |
|
136 | } | |
132 |
|
137 | |||
133 | // Updates graph |
|
138 | // Updates graph | |
134 | ui->widget->replot(); |
|
139 | ui->widget->replot(); | |
135 | } |
|
140 | } | |
136 |
|
141 | |||
137 | void VisualizationGraphWidget::setRange(std::shared_ptr<Variable> variable, const SqpRange &range) |
|
142 | void VisualizationGraphWidget::setRange(std::shared_ptr<Variable> variable, const SqpRange &range) | |
138 | { |
|
143 | { | |
139 | // Note: in case of different axes that depends on variable, we could start with a code like |
|
144 | // Note: in case of different axes that depends on variable, we could start with a code like | |
140 | // that: |
|
145 | // that: | |
141 | // auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable); |
|
146 | // auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable); | |
142 | // for (auto it = componentsIt.first; it != componentsIt.second;) { |
|
147 | // for (auto it = componentsIt.first; it != componentsIt.second;) { | |
143 | // } |
|
148 | // } | |
144 | ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd); |
|
149 | ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd); | |
145 | ui->widget->replot(); |
|
150 | ui->widget->replot(); | |
146 | } |
|
151 | } | |
147 |
|
152 | |||
148 | void VisualizationGraphWidget::setYRange(const SqpRange &range) |
|
153 | void VisualizationGraphWidget::setYRange(const SqpRange &range) | |
149 | { |
|
154 | { | |
150 | ui->widget->yAxis->setRange(range.m_TStart, range.m_TEnd); |
|
155 | ui->widget->yAxis->setRange(range.m_TStart, range.m_TEnd); | |
151 | } |
|
156 | } | |
152 |
|
157 | |||
153 | SqpRange VisualizationGraphWidget::graphRange() const noexcept |
|
158 | SqpRange VisualizationGraphWidget::graphRange() const noexcept | |
154 | { |
|
159 | { | |
155 | auto graphRange = ui->widget->xAxis->range(); |
|
160 | auto graphRange = ui->widget->xAxis->range(); | |
156 | return SqpRange{graphRange.lower, graphRange.upper}; |
|
161 | return SqpRange{graphRange.lower, graphRange.upper}; | |
157 | } |
|
162 | } | |
158 |
|
163 | |||
159 | void VisualizationGraphWidget::setGraphRange(const SqpRange &range) |
|
164 | void VisualizationGraphWidget::setGraphRange(const SqpRange &range) | |
160 | { |
|
165 | { | |
161 | qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START"); |
|
166 | qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START"); | |
162 | ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd); |
|
167 | ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd); | |
163 | ui->widget->replot(); |
|
168 | ui->widget->replot(); | |
164 | qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END"); |
|
169 | qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END"); | |
165 | } |
|
170 | } | |
166 |
|
171 | |||
167 | void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor) |
|
172 | void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor) | |
168 | { |
|
173 | { | |
169 | if (visitor) { |
|
174 | if (visitor) { | |
170 | visitor->visit(this); |
|
175 | visitor->visit(this); | |
171 | } |
|
176 | } | |
172 | else { |
|
177 | else { | |
173 | qCCritical(LOG_VisualizationGraphWidget()) |
|
178 | qCCritical(LOG_VisualizationGraphWidget()) | |
174 | << tr("Can't visit widget : the visitor is null"); |
|
179 | << tr("Can't visit widget : the visitor is null"); | |
175 | } |
|
180 | } | |
176 | } |
|
181 | } | |
177 |
|
182 | |||
178 | bool VisualizationGraphWidget::canDrop(const Variable &variable) const |
|
183 | bool VisualizationGraphWidget::canDrop(const Variable &variable) const | |
179 | { |
|
184 | { | |
180 | /// @todo : for the moment, a graph can always accomodate a variable |
|
185 | /// @todo : for the moment, a graph can always accomodate a variable | |
181 | Q_UNUSED(variable); |
|
186 | Q_UNUSED(variable); | |
182 | return true; |
|
187 | return true; | |
183 | } |
|
188 | } | |
184 |
|
189 | |||
185 | bool VisualizationGraphWidget::contains(const Variable &variable) const |
|
190 | bool VisualizationGraphWidget::contains(const Variable &variable) const | |
186 | { |
|
191 | { | |
187 | // Finds the variable among the keys of the map |
|
192 | // Finds the variable among the keys of the map | |
188 | auto variablePtr = &variable; |
|
193 | auto variablePtr = &variable; | |
189 | auto findVariable |
|
194 | auto findVariable | |
190 | = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); }; |
|
195 | = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); }; | |
191 |
|
196 | |||
192 | auto end = impl->m_VariableToPlotMultiMap.cend(); |
|
197 | auto end = impl->m_VariableToPlotMultiMap.cend(); | |
193 | auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable); |
|
198 | auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable); | |
194 | return it != end; |
|
199 | return it != end; | |
195 | } |
|
200 | } | |
196 |
|
201 | |||
197 | QString VisualizationGraphWidget::name() const |
|
202 | QString VisualizationGraphWidget::name() const | |
198 | { |
|
203 | { | |
199 | return ui->graphNameLabel->text(); |
|
204 | return ui->graphNameLabel->text(); | |
200 | } |
|
205 | } | |
201 |
|
206 | |||
202 | void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept |
|
207 | void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept | |
203 | { |
|
208 | { | |
204 | QMenu graphMenu{}; |
|
209 | QMenu graphMenu{}; | |
205 |
|
210 | |||
206 | // Iterates on variables (unique keys) |
|
211 | // Iterates on variables (unique keys) | |
207 | for (auto it = impl->m_VariableToPlotMultiMap.cbegin(), |
|
212 | for (auto it = impl->m_VariableToPlotMultiMap.cbegin(), | |
208 | end = impl->m_VariableToPlotMultiMap.cend(); |
|
213 | end = impl->m_VariableToPlotMultiMap.cend(); | |
209 | it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) { |
|
214 | it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) { | |
210 | // 'Remove variable' action |
|
215 | // 'Remove variable' action | |
211 | graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()), |
|
216 | graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()), | |
212 | [ this, var = it->first ]() { removeVariable(var); }); |
|
217 | [ this, var = it->first ]() { removeVariable(var); }); | |
213 | } |
|
218 | } | |
214 |
|
219 | |||
215 | if (!graphMenu.isEmpty()) { |
|
220 | if (!graphMenu.isEmpty()) { | |
216 | graphMenu.exec(mapToGlobal(pos)); |
|
221 | graphMenu.exec(mapToGlobal(pos)); | |
217 | } |
|
222 | } | |
218 | } |
|
223 | } | |
219 |
|
224 | |||
220 | void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2) |
|
225 | void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2) | |
221 | { |
|
226 | { | |
222 | qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged") |
|
227 | qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged") | |
223 | << QThread::currentThread()->objectName() << "DoAcqui" |
|
228 | << QThread::currentThread()->objectName() << "DoAcqui" | |
224 | << impl->m_DoAcquisition; |
|
229 | << impl->m_DoAcquisition; | |
225 |
|
230 | |||
226 | auto graphRange = SqpRange{t1.lower, t1.upper}; |
|
231 | auto graphRange = SqpRange{t1.lower, t1.upper}; | |
227 | auto oldGraphRange = SqpRange{t2.lower, t2.upper}; |
|
232 | auto oldGraphRange = SqpRange{t2.lower, t2.upper}; | |
228 |
|
233 | |||
229 | if (impl->m_DoAcquisition) { |
|
234 | if (impl->m_DoAcquisition) { | |
230 | QVector<std::shared_ptr<Variable> > variableUnderGraphVector; |
|
235 | QVector<std::shared_ptr<Variable> > variableUnderGraphVector; | |
231 |
|
236 | |||
232 | for (auto it = impl->m_VariableToPlotMultiMap.begin(), |
|
237 | for (auto it = impl->m_VariableToPlotMultiMap.begin(), | |
233 | end = impl->m_VariableToPlotMultiMap.end(); |
|
238 | end = impl->m_VariableToPlotMultiMap.end(); | |
234 | it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) { |
|
239 | it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) { | |
235 | variableUnderGraphVector.push_back(it->first); |
|
240 | variableUnderGraphVector.push_back(it->first); | |
236 | } |
|
241 | } | |
237 | emit requestDataLoading(std::move(variableUnderGraphVector), graphRange, oldGraphRange, |
|
242 | emit requestDataLoading(std::move(variableUnderGraphVector), graphRange, oldGraphRange, | |
238 | !impl->m_IsCalibration); |
|
243 | !impl->m_IsCalibration); | |
239 |
|
244 | |||
240 | if (!impl->m_IsCalibration) { |
|
245 | if (!impl->m_IsCalibration) { | |
241 | qCDebug(LOG_VisualizationGraphWidget()) |
|
246 | qCDebug(LOG_VisualizationGraphWidget()) | |
242 | << tr("TORM: VisualizationGraphWidget::Synchronize notify !!") |
|
247 | << tr("TORM: VisualizationGraphWidget::Synchronize notify !!") | |
243 | << QThread::currentThread()->objectName() << graphRange << oldGraphRange; |
|
248 | << QThread::currentThread()->objectName() << graphRange << oldGraphRange; | |
244 | emit synchronize(graphRange, oldGraphRange); |
|
249 | emit synchronize(graphRange, oldGraphRange); | |
245 | } |
|
250 | } | |
246 | } |
|
251 | } | |
247 | } |
|
252 | } | |
248 |
|
253 | |||
249 | void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept |
|
254 | void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept | |
250 | { |
|
255 | { | |
251 | // Handles plot rendering when mouse is moving |
|
256 | // Handles plot rendering when mouse is moving | |
252 | impl->m_RenderingDelegate->onMouseMove(event); |
|
257 | impl->m_RenderingDelegate->onMouseMove(event); | |
253 | } |
|
258 | } | |
254 |
|
259 | |||
255 | void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept |
|
260 | void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept | |
256 | { |
|
261 | { | |
257 | auto zoomOrientations = QFlags<Qt::Orientation>{}; |
|
262 | auto zoomOrientations = QFlags<Qt::Orientation>{}; | |
258 |
|
263 | |||
259 | // Lambda that enables a zoom orientation if the key modifier related to this orientation |
|
264 | // Lambda that enables a zoom orientation if the key modifier related to this orientation | |
260 | // has |
|
265 | // has | |
261 | // been pressed |
|
266 | // been pressed | |
262 | auto enableOrientation |
|
267 | auto enableOrientation | |
263 | = [&zoomOrientations, event](const auto &orientation, const auto &modifier) { |
|
268 | = [&zoomOrientations, event](const auto &orientation, const auto &modifier) { | |
264 | auto orientationEnabled = event->modifiers().testFlag(modifier); |
|
269 | auto orientationEnabled = event->modifiers().testFlag(modifier); | |
265 | zoomOrientations.setFlag(orientation, orientationEnabled); |
|
270 | zoomOrientations.setFlag(orientation, orientationEnabled); | |
266 | }; |
|
271 | }; | |
267 | enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER); |
|
272 | enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER); | |
268 | enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER); |
|
273 | enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER); | |
269 |
|
274 | |||
270 | ui->widget->axisRect()->setRangeZoom(zoomOrientations); |
|
275 | ui->widget->axisRect()->setRangeZoom(zoomOrientations); | |
271 | } |
|
276 | } | |
272 |
|
277 | |||
273 | void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept |
|
278 | void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept | |
274 | { |
|
279 | { | |
275 | impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier); |
|
280 | impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier); | |
276 | } |
|
281 | } | |
277 |
|
282 | |||
278 | void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept |
|
283 | void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept | |
279 | { |
|
284 | { | |
280 | impl->m_IsCalibration = false; |
|
285 | impl->m_IsCalibration = false; | |
281 | } |
|
286 | } | |
282 |
|
287 | |||
283 | void VisualizationGraphWidget::onDataCacheVariableUpdated() |
|
288 | void VisualizationGraphWidget::onDataCacheVariableUpdated() | |
284 | { |
|
289 | { | |
285 | // NOTE: |
|
|||
286 | // We don't want to call the method for each component of a variable unitarily, but for |
|
|||
287 | // all |
|
|||
288 | // its components at once (eg its three components in the case of a vector). |
|
|||
289 |
|
||||
290 | // The unordered_multimap does not do this easily, so the question is whether to: |
|
|||
291 | // - use an ordered_multimap and the algos of std to group the values by key |
|
|||
292 | // - use a map (unique keys) and store as values directly the list of components |
|
|||
293 |
|
||||
294 | auto graphRange = ui->widget->xAxis->range(); |
|
290 | auto graphRange = ui->widget->xAxis->range(); | |
295 | auto dateTime = SqpRange{graphRange.lower, graphRange.upper}; |
|
291 | auto dateTime = SqpRange{graphRange.lower, graphRange.upper}; | |
296 |
|
292 | |||
297 |
for (auto it |
|
293 | for (auto &variableEntry : impl->m_VariableToPlotMultiMap) { | |
298 | it != impl->m_VariableToPlotMultiMap.cend(); ++it) { |
|
294 | auto variable = variableEntry.first; | |
299 | auto variable = it->first; |
|
|||
300 | qCDebug(LOG_VisualizationGraphWidget()) |
|
295 | qCDebug(LOG_VisualizationGraphWidget()) | |
301 | << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range(); |
|
296 | << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range(); | |
302 | qCDebug(LOG_VisualizationGraphWidget()) |
|
297 | qCDebug(LOG_VisualizationGraphWidget()) | |
303 | << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime; |
|
298 | << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime; | |
304 | if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) { |
|
299 | if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) { | |
305 |
|
300 | VisualizationGraphHelper::updateData(variableEntry.second, variable->dataSeries().get(), | ||
306 | VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second, |
|
301 | variable->range()); | |
307 | variable->dataSeries(), variable->range()); |
|
|||
308 | } |
|
302 | } | |
309 | } |
|
303 | } | |
310 | } |
|
304 | } | |
311 |
|
305 | |||
312 | void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable, |
|
306 | void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable, | |
313 | const SqpRange &range) |
|
307 | const SqpRange &range) | |
314 | { |
|
308 | { | |
315 |
auto |
|
309 | auto it = impl->m_VariableToPlotMultiMap.find(variable); | |
316 | for (auto it = componentsIt.first; it != componentsIt.second;) { |
|
310 | if (it != impl->m_VariableToPlotMultiMap.end()) { | |
317 | VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second, |
|
311 | VisualizationGraphHelper::updateData(it->second, variable->dataSeries().get(), range); | |
318 | variable->dataSeries(), range); |
|
|||
319 | } |
|
312 | } | |
320 | } |
|
313 | } |
General Comments 0
You need to be logged in to leave comments.
Login now