GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r614:d53842017d03

Merge branch 'feature/ValueRange' into develop

Alexandre Leroux -

r614:d53842017d03

parent child

Context file:

r614:d53842017d03

Collapse all files

core/include/Common/SortUtils.h +52 0

@@ -59,6 +59,58 struct SortUtils {
59		59
60	return sortedData;	60	return sortedData;
61	}	61	}
		62
		63	/**
		64	* Compares two values that can be NaN. This method is intended to be used as a compare function
		65	* for searching min value by excluding NaN values.
		66	*
		67	* Examples of use:
		68	* - f({1, 3, 2, 4, 5}) will return 1
		69	* - f({NaN, 3, 2, 4, 5}) will return 2 (NaN is excluded)
		70	* - f({NaN, NaN, 3, NaN, NaN}) will return 3 (NaN are excluded)
		71	* - f({NaN, NaN, NaN, NaN, NaN}) will return NaN (no existing value)
		72	*
		73	* @param v1 first value
		74	* @param v2 second value
		75	* @return true if v1 < v2, false otherwise
		76	* @sa std::min_element
		77	*/
		78	template <typename T>
		79	static bool minCompareWithNaN(const T &v1, const T &v2)
		80	{
		81	// Table used with NaN values:
		82	// NaN < v2 -> false
		83	// v1 < NaN -> true
		84	// NaN < NaN -> false
		85	// v1 < v2 -> v1 < v2
		86	return std::isnan(v1) ? false : std::isnan(v2) \|\| (v1 < v2);
		87	}
		88
		89	/**
		90	* Compares two values that can be NaN. This method is intended to be used as a compare function
		91	* for searching max value by excluding NaN values.
		92	*
		93	* Examples of use:
		94	* - f({1, 3, 2, 4, 5}) will return 5
		95	* - f({1, 3, 2, 4, NaN}) will return 4 (NaN is excluded)
		96	* - f({NaN, NaN, 3, NaN, NaN}) will return 3 (NaN are excluded)
		97	* - f({NaN, NaN, NaN, NaN, NaN}) will return NaN (no existing value)
		98	*
		99	* @param v1 first value
		100	* @param v2 second value
		101	* @return true if v1 < v2, false otherwise
		102	* @sa std::max_element
		103	*/
		104	template <typename T>
		105	static bool maxCompareWithNaN(const T &v1, const T &v2)
		106	{
		107	// Table used with NaN values:
		108	// NaN < v2 -> true
		109	// v1 < NaN -> false
		110	// NaN < NaN -> false
		111	// v1 < v2 -> v1 < v2
		112	return std::isnan(v1) ? true : !std::isnan(v2) && (v1 < v2);
		113	}
62	};	114	};
63		115
64	#endif // SCIQLOP_SORTUTILS_H	116	#endif // SCIQLOP_SORTUTILS_H

core/include/Data/ArrayData.h +20 0

@@ -70,6 +70,26 public:
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	/// @return the min value among all components
		74	double min() const
		75	{
		76	auto end = m_Its.cend();
		77	auto it = std::min_element(m_Its.cbegin(), end, [](const auto &it1, const auto &it2) {
		78	return SortUtils::minCompareWithNaN(it1, it2);
		79	});
		80	return it != end ? **it : std::numeric_limits<double>::quiet_NaN();
		81	}
		82
		83	/// @return the max value among all components
		84	double max() const
		85	{
		86	auto end = m_Its.cend();
		87	auto it = std::max_element(m_Its.cbegin(), end, [](const auto &it1, const auto &it2) {
		88	return SortUtils::maxCompareWithNaN(it1, it2);
		89	});
		90	return it != end ? **it : std::numeric_limits<double>::quiet_NaN();
		91	}
		92
73	void next()	93	void next()
74	{	94	{
75	for (auto &it : m_Its) {	95	for (auto &it : m_Its) {

core/include/Data/DataSeries.h +42 -15

                 double x() const override { return m_XIt->at(0); }
                 double value() const override { return m_ValuesIt->at(0); }
                 double value(int componentIndex) const override { return m_ValuesIt->at(componentIndex); }
+                double minValue() const override { return m_ValuesIt->min(); }
+                double maxValue() const override { return m_ValuesIt->max(); }
             private:
                 ArrayData<1>::Iterator m_XIt;
                         std::make_unique<dataseries_detail::IteratorValue<Dim> >(*this, false)}};
                 }
-                /// @sa IDataSeries::minData()
+                /// @sa IDataSeries::minXAxisData()
-                DataSeriesIterator minData(double minXAxisData) const override
+                DataSeriesIterator minXAxisData(double minXAxisData) const override
                 {
                     return std::lower_bound(
                         cbegin(), cend(), minXAxisData,
                         [](const auto &itValue, const auto &value) { return itValue.x() < value; });
                 }
-                /// @sa IDataSeries::maxData()
+                /// @sa IDataSeries::maxXAxisData()
-                DataSeriesIterator maxData(double maxXAxisData) const override
+                DataSeriesIterator maxXAxisData(double maxXAxisData) const override
                 {
                     // Gets the first element that greater than max value
                     auto it = std::upper_bound(
                     return it == cbegin() ? cend() : --it;
                 }
-                std::pair<DataSeriesIterator, DataSeriesIterator> subData(double min, double max) const override
+                std::pair<DataSeriesIterator, DataSeriesIterator> xAxisRange(double minXAxisData,
+                                                                             double maxXAxisData) const override
                 {
-                    if (min > max) {
+                    if (minXAxisData > maxXAxisData) {
-                        std::swap(min, max);
+                        std::swap(minXAxisData, maxXAxisData);
                     }
                     auto begin = cbegin();
                     auto end = cend();
-                    auto lowerIt
+                    auto lowerIt = std::lower_bound(
-                        = std::lower_bound(begin, end, min, [](const auto &itValue, const auto &value) {
+                        begin, end, minXAxisData,
-                              return itValue.x() < value;
+                        [](const auto &itValue, const auto &value) { return itValue.x() < value; });
-                          });
+                    auto upperIt = std::upper_bound(
-                    auto upperIt
+                        begin, end, maxXAxisData,
-                        = std::upper_bound(begin, end, max, [](const auto &value, const auto &itValue) {
+                        [](const auto &value, const auto &itValue) { return value < itValue.x(); });
-                              return value < itValue.x();
-                          });
                     return std::make_pair(lowerIt, upperIt);
                 }
+                std::pair<DataSeriesIterator, DataSeriesIterator>
+                valuesBounds(double minXAxisData, double maxXAxisData) const override
+                {
+                    // Places iterators to the correct x-axis range
+                    auto xAxisRangeIts = xAxisRange(minXAxisData, maxXAxisData);
+                    // Returns end iterators if the range is empty
+                    if (xAxisRangeIts.first == xAxisRangeIts.second) {
+                        return std::make_pair(cend(), cend());
+                    }
+                    // Gets the iterator on the min of all values data
+                    auto minIt = std::min_element(
+                        xAxisRangeIts.first, xAxisRangeIts.second, [](const auto &it1, const auto &it2) {
+                            return SortUtils::minCompareWithNaN(it1.minValue(), it2.minValue());
+                        });
+                    // Gets the iterator on the max of all values data
+                    auto maxIt = std::max_element(
+                        xAxisRangeIts.first, xAxisRangeIts.second, [](const auto &it1, const auto &it2) {
+                            return SortUtils::maxCompareWithNaN(it1.maxValue(), it2.maxValue());
+                        });
+                    return std::make_pair(minIt, maxIt);
+                }
                 // /////// //
                 // Mutexes //
                 // /////// //

core/include/Data/DataSeriesIterator.h +6 0

                     virtual double x() const = 0;
                     virtual double value() const = 0;
                     virtual double value(int componentIndex) const = 0;
+                    virtual double minValue() const = 0;
+                    virtual double maxValue() const = 0;
                 };
                 explicit DataSeriesIteratorValue(std::unique_ptr<Impl> impl);
                 double value() const;
                 /// Gets value data depending on an index
                 double value(int componentIndex) const;
+                /// Gets min of all values data
+                double minValue() const;
+                /// Gets max of all values data
+                double maxValue() const;
             private:
                 std::unique_ptr<Impl> m_Impl;

core/include/Data/IDataSeries.h +13 -5

@@ -72,14 +72,22 public:
72		72
73	/// @return the iterator to the first entry of the data series whose x-axis data is greater than	73	/// @return the iterator to the first entry of the data series whose x-axis data is greater than
74	/// or equal to the value passed in parameter, or the end iterator if there is no matching value	74	/// or equal to the value passed in parameter, or the end iterator if there is no matching value
75	virtual DataSeriesIterator minData(double minXAxisData) const = 0;	75	virtual DataSeriesIterator minXAxisData(double minXAxisData) const = 0;
76		76
77	/// @return the iterator to the last entry of the data series whose x-axis data is less than or	77	/// @return the iterator to the last entry of the data series whose x-axis data is less than or
78	/// equal to the value passed in parameter, or the end iterator if there is no matching value	78	/// equal to the value passed in parameter, or the end iterator if there is no matching value
79	virtual DataSeriesIterator maxData(double maxXAxisData) const = 0;	79	virtual DataSeriesIterator maxXAxisData(double maxXAxisData) const = 0;
80		80
81	virtual std::pair<DataSeriesIterator, DataSeriesIterator> subData(double min,	81	/// @return the iterators pointing to the range of data whose x-axis values are between min and
82	double max) const = 0;	82	/// max passed in parameters
		83	virtual std::pair<DataSeriesIterator, DataSeriesIterator>
		84	xAxisRange(double minXAxisData, double maxXAxisData) const = 0;
		85
		86	/// @return two iterators pointing to the data that have respectively the min and the max value
		87	/// data of a data series' range. The search is performed for a given x-axis range.
		88	/// @sa xAxisRange()
		89	virtual std::pair<DataSeriesIterator, DataSeriesIterator>
		90	valuesBounds(double minXAxisData, double maxXAxisData) const = 0;
83		91
84	// /////// //	92	// /////// //
85	// Mutexes //	93	// Mutexes //

core/src/Data/DataSeriesIterator.cpp +10 0

@@ -47,6 +47,16 double DataSeriesIteratorValue::value(int componentIndex) const
47	return m_Impl->value(componentIndex);	47	return m_Impl->value(componentIndex);
48	}	48	}
49		49
		50	double DataSeriesIteratorValue::minValue() const
		51	{
		52	return m_Impl->minValue();
		53	}
		54
		55	double DataSeriesIteratorValue::maxValue() const
		56	{
		57	return m_Impl->maxValue();
		58	}
		59
50	DataSeriesIterator::DataSeriesIterator(DataSeriesIteratorValue value)	60	DataSeriesIterator::DataSeriesIterator(DataSeriesIteratorValue value)
51	: m_CurrentValue{std::move(value)}	61	: m_CurrentValue{std::move(value)}
52	{	62	{

core/src/Data/ScalarSeries.cpp +1 -1

                 auto subValuesData = QVector<double>();
                 this->lockRead();
                 {
-                    auto bounds = subData(range.m_TStart, range.m_TEnd);
+                    auto bounds = xAxisRange(range.m_TStart, range.m_TEnd);
                     for (auto it = bounds.first; it != bounds.second; ++it) {
                         subXAxisData.append(it->x());
                         subValuesData.append(it->value());

core/src/Data/VectorSeries.cpp +1 -1

                 this->lockRead();
                 {
-                    auto bounds = subData(range.m_TStart, range.m_TEnd);
+                    auto bounds = xAxisRange(range.m_TStart, range.m_TEnd);
                     for (auto it = bounds.first; it != bounds.second; ++it) {
                         subXAxisData.append(it->x());
                         subXValuesData.append(it->value(0));

core/src/Variable/VariableModel.cpp +2 -2

                             case TSTART_COLUMN:
                                 // Shows the min value of the data series above the range tstart
                                 return dateTimeVariant([min = variable->range().m_TStart](
-                                    const auto &dataSeries) { return dataSeries.minData(min); });
+                                    const auto &dataSeries) { return dataSeries.minXAxisData(min); });
                             case TEND_COLUMN:
                                 // Shows the max value of the data series under the range tend
                                 return dateTimeVariant([max = variable->range().m_TEnd](
-                                    const auto &dataSeries) { return dataSeries.maxData(max); });
+                                    const auto &dataSeries) { return dataSeries.maxXAxisData(max); });
                             case UNIT_COLUMN:
                                 return variable->metadata().value(QStringLiteral("units"));
                             case MISSION_COLUMN:

core/tests/Data/TestDataSeries.cpp +230 -64

@@ -1,13 +1,64
1	#include "Data/DataSeries.h"	1	#include "Data/DataSeries.h"
2	#include "Data/ScalarSeries.h"	2	#include "Data/ScalarSeries.h"
		3	#include "Data/VectorSeries.h"
3		4
4	#include <QObject>	5	#include <QObject>
5	#include <QtTest>	6	#include <QtTest>
6		7
7	Q_DECLARE_METATYPE(std::shared_ptr<ScalarSeries>)	8	Q_DECLARE_METATYPE(std::shared_ptr<ScalarSeries>)
		9	Q_DECLARE_METATYPE(std::shared_ptr<VectorSeries>)
8		10
9	class TestDataSeries : public QObject {	11	class TestDataSeries : public QObject {
10	Q_OBJECT	12	Q_OBJECT
		13	private:
		14	template <typename T>
		15	void testValuesBoundsStructure()
		16	{
		17	// ////////////// //
		18	// Test structure //
		19	// ////////////// //
		20
		21	// Data series to get values bounds
		22	QTest::addColumn<std::shared_ptr<T> >("dataSeries");
		23
		24	// x-axis range
		25	QTest::addColumn<double>("minXAxis");
		26	QTest::addColumn<double>("maxXAxis");
		27
		28	// Expected results
		29	QTest::addColumn<bool>(
		30	"expectedOK"); // Test is expected to be ok (i.e. method doesn't return end iterators)
		31	QTest::addColumn<double>("expectedMinValue");
		32	QTest::addColumn<double>("expectedMaxValue");
		33	}
		34
		35	template <typename T>
		36	void testValuesBounds()
		37	{
		38	QFETCH(std::shared_ptr<T>, dataSeries);
		39	QFETCH(double, minXAxis);
		40	QFETCH(double, maxXAxis);
		41
		42	QFETCH(bool, expectedOK);
		43	QFETCH(double, expectedMinValue);
		44	QFETCH(double, expectedMaxValue);
		45
		46	auto minMaxIts = dataSeries->valuesBounds(minXAxis, maxXAxis);
		47	auto end = dataSeries->cend();
		48
		49	// Checks iterators with expected result
		50	QCOMPARE(expectedOK, minMaxIts.first != end && minMaxIts.second != end);
		51
		52	if (expectedOK) {
		53	auto compare = [](const auto &v1, const auto &v2) {
		54	return (std::isnan(v1) && std::isnan(v2)) \|\| v1 == v2;
		55	};
		56
		57	QVERIFY(compare(expectedMinValue, minMaxIts.first->minValue()));
		58	QVERIFY(compare(expectedMaxValue, minMaxIts.second->maxValue()));
		59	}
		60	}
		61
11	private slots:	62	private slots:
12	/// Input test data	63	/// Input test data
13	/// @sa testCtor()	64	/// @sa testCtor()
@@ -24,25 +75,39 private slots:
24	void testMerge();	75	void testMerge();
25		76
26	/// Input test data	77	/// Input test data
27	/// @sa testMinData()	78	/// @sa testMinXAxisData()
28	void testMinData_data();	79	void testMinXAxisData_data();
		80
		81	/// Tests get min x-axis data of a data series
		82	void testMinXAxisData();
		83
		84	/// Input test data
		85	/// @sa testMaxXAxisData()
		86	void testMaxXAxisData_data();
		87
		88	/// Tests get max x-axis data of a data series
		89	void testMaxXAxisData();
		90
		91	/// Input test data
		92	/// @sa testXAxisRange()
		93	void testXAxisRange_data();
29		94
30	/// Tests get ~~min data~~ of a data series	95	/// Tests get x-axis range of a data series
31	void test~~MinData~~();	96	void testXAxisRange();
32		97
33	/// Input test data	98	/// Input test data
34	/// @sa test~~MaxData~~()	99	/// @sa testValuesBoundsScalar()
35	void test~~MaxData~~_data();	100	void testValuesBoundsScalar_data();
36		101
37	/// Tests get ~~max data of a data~~ series	102	/// Tests get values bounds of a scalar series
38	void test~~MaxData~~();	103	void testValuesBoundsScalar();
39		104
40	/// Input test data	105	/// Input test data
41	/// @sa test~~Subdata~~()	106	/// @sa testValuesBoundsVector()
42	void test~~Subdata~~_data();	107	void testValuesBoundsVector_data();
43		108
44	/// Tests get ~~subdata of two data~~ series	109	/// Tests get values bounds of a vector series
45	void test~~Subdata~~();	110	void testValuesBoundsVector();
46	};	111	};
47		112
48	void TestDataSeries::testCtor_data()	113	void TestDataSeries::testCtor_data()
@@ -108,12 +173,23 void TestDataSeries::testCtor()
108		173
109	namespace {	174	namespace {
110		175
111	std::shared_ptr<ScalarSeries> createSeries(QVector<double> xAxisData, ~~QVector~~<~~double~~> ~~valuesData~~)	176	std::shared_ptr<ScalarSeries> createScalarSeries(QVector<double> xAxisData,
		177	QVector<double> valuesData)
112	{	178	{
113	return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},	179	return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
114	Unit{});	180	Unit{});
115	}	181	}
116		182
		183	std::shared_ptr<VectorSeries> createVectorSeries(QVector<double> xAxisData,
		184	QVector<double> xValuesData,
		185	QVector<double> yValuesData,
		186	QVector<double> zValuesData)
		187	{
		188	return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(xValuesData),
		189	std::move(yValuesData), std::move(zValuesData), Unit{},
		190	Unit{});
		191	}
		192
117	} // namespace	193	} // namespace
118		194
119	void TestDataSeries::testMerge_data()	195	void TestDataSeries::testMerge_data()
@@ -135,26 +211,26 void TestDataSeries::testMerge_data()
135	// ////////// //	211	// ////////// //
136		212
137	QTest::newRow("sortedMerge")	213	QTest::newRow("sortedMerge")
138	<< createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})	214	<< createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
139	<< createSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})	215	<< createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
140	<< QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}	216	<< QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
141	<< QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};	217	<< QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
142		218
143	QTest::newRow("unsortedMerge")	219	QTest::newRow("unsortedMerge")
144	<< createSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})	220	<< createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
145	<< createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})	221	<< createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
146	<< QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}	222	<< QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
147	<< QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};	223	<< QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
148		224
149	QTest::newRow("unsortedMerge2")	225	QTest::newRow("unsortedMerge2")
150	<< createSeries({1., 2., 8., 9., 10}, {100., 200., 300., 400., 500.})	226	<< createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 300., 400., 500.})
151	<< createSeries({3., 4., 5., 6., 7.}, {600., 700., 800., 900., 1000.})	227	<< createScalarSeries({3., 4., 5., 6., 7.}, {600., 700., 800., 900., 1000.})
152	<< QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}	228	<< QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
153	<< QVector<double>{100., 200., 600., 700., 800., 900., 1000., 300., 400., 500.};	229	<< QVector<double>{100., 200., 600., 700., 800., 900., 1000., 300., 400., 500.};
154		230
155	QTest::newRow("unsortedMerge3")	231	QTest::newRow("unsortedMerge3")
156	<< createSeries({3., 5., 8., 7., 2}, {100., 200., 300., 400., 500.})	232	<< createScalarSeries({3., 5., 8., 7., 2}, {100., 200., 300., 400., 500.})
157	<< createSeries({6., 4., 9., 10., 1.}, {600., 700., 800., 900., 1000.})	233	<< createScalarSeries({6., 4., 9., 10., 1.}, {600., 700., 800., 900., 1000.})
158	<< QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}	234	<< QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
159	<< QVector<double>{1000., 500., 100., 700., 200., 600., 400., 300., 800., 900.};	235	<< QVector<double>{1000., 500., 100., 700., 200., 600., 400., 300., 800., 900.};
160	}	236	}
@@ -181,7 +257,7 void TestDataSeries::testMerge()
181	seriesValuesData.cbegin()));	257	seriesValuesData.cbegin()));
182	}	258	}
183		259
184	void TestDataSeries::testMinData_data()	260	void TestDataSeries::testMinXAxisData_data()
185	{	261	{
186	// ////////////// //	262	// ////////////// //
187	// Test structure //	263	// Test structure //
@@ -203,21 +279,26 void TestDataSeries::testMinData_data()
203	// Test cases //	279	// Test cases //
204	// ////////// //	280	// ////////// //
205		281
206	QTest::newRow("minData1") << createSeries({1., 2., 3., 4., 5.}, {~~100.~~, ~~200.~~, ~~300.~~, ~~400.~~, ~~500.~~})	282	QTest::newRow("minData1") << createScalarSeries({1., 2., 3., 4., 5.},
		283	{100., 200., 300., 400., 500.})
207	<< 0. << true << 1.;	284	<< 0. << true << 1.;
208	QTest::newRow("minData2") << createSeries({1., 2., 3., 4., 5.}, {~~100.~~, ~~200.~~, ~~300.~~, ~~400.~~, ~~500.~~})	285	QTest::newRow("minData2") << createScalarSeries({1., 2., 3., 4., 5.},
		286	{100., 200., 300., 400., 500.})
209	<< 1. << true << 1.;	287	<< 1. << true << 1.;
210	QTest::newRow("minData3") << createSeries({1., 2., 3., 4., 5.}, {~~100.~~, ~~200.~~, ~~300.~~, ~~400.~~, ~~500.~~})	288	QTest::newRow("minData3") << createScalarSeries({1., 2., 3., 4., 5.},
		289	{100., 200., 300., 400., 500.})
211	<< 1.1 << true << 2.;	290	<< 1.1 << true << 2.;
212	QTest::newRow("minData4") << createSeries({1., 2., 3., 4., 5.}, {~~100.~~, ~~200.~~, ~~300.~~, ~~400.~~, ~~500.~~})	291	QTest::newRow("minData4") << createScalarSeries({1., 2., 3., 4., 5.},
		292	{100., 200., 300., 400., 500.})
213	<< 5. << true << 5.;	293	<< 5. << true << 5.;
214	QTest::newRow("minData5") << createSeries({1., 2., 3., 4., 5.}, {~~100.~~, ~~200.~~, ~~300.~~, ~~400.~~, ~~500.~~})	294	QTest::newRow("minData5") << createScalarSeries({1., 2., 3., 4., 5.},
		295	{100., 200., 300., 400., 500.})
215	<< 5.1 << false << std::numeric_limits<double>::quiet_NaN();	296	<< 5.1 << false << std::numeric_limits<double>::quiet_NaN();
216	QTest::newRow("minData6") << createSeries({}, {}) << 1.1 << false	297	QTest::newRow("minData6") << createScalarSeries({}, {}) << 1.1 << false
217	<< std::numeric_limits<double>::quiet_NaN();	298	<< std::numeric_limits<double>::quiet_NaN();
218	}	299	}
219		300
220	void TestDataSeries::testMinData()	301	void TestDataSeries::testMinXAxisData()
221	{	302	{
222	QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);	303	QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
223	QFETCH(double, min);	304	QFETCH(double, min);
@@ -225,7 +306,7 void TestDataSeries::testMinData()
225	QFETCH(bool, expectedOK);	306	QFETCH(bool, expectedOK);
226	QFETCH(double, expectedMin);	307	QFETCH(double, expectedMin);
227		308
228	auto it = dataSeries->minData(min);	309	auto it = dataSeries->minXAxisData(min);
229		310
230	QCOMPARE(expectedOK, it != dataSeries->cend());	311	QCOMPARE(expectedOK, it != dataSeries->cend());
231		312
@@ -235,7 +316,7 void TestDataSeries::testMinData()
235	}	316	}
236	}	317	}
237		318
238	void TestDataSeries::testMaxData_data()	319	void TestDataSeries::testMaxXAxisData_data()
239	{	320	{
240	// ////////////// //	321	// ////////////// //
241	// Test structure //	322	// Test structure //
@@ -257,21 +338,26 void TestDataSeries::testMaxData_data()
257	// Test cases //	338	// Test cases //
258	// ////////// //	339	// ////////// //
259		340
260	QTest::newRow("maxData1") << createSeries({1., 2., 3., 4., 5.}, {~~100.~~, ~~200.~~, ~~300.~~, ~~400.~~, ~~500.~~})	341	QTest::newRow("maxData1") << createScalarSeries({1., 2., 3., 4., 5.},
		342	{100., 200., 300., 400., 500.})
261	<< 6. << true << 5.;	343	<< 6. << true << 5.;
262	QTest::newRow("maxData2") << createSeries({1., 2., 3., 4., 5.}, {~~100.~~, ~~200.~~, ~~300.~~, ~~400.~~, ~~500.~~})	344	QTest::newRow("maxData2") << createScalarSeries({1., 2., 3., 4., 5.},
		345	{100., 200., 300., 400., 500.})
263	<< 5. << true << 5.;	346	<< 5. << true << 5.;
264	QTest::newRow("maxData3") << createSeries({1., 2., 3., 4., 5.}, {~~100.~~, ~~200.~~, ~~300.~~, ~~400.~~, ~~500.~~})	347	QTest::newRow("maxData3") << createScalarSeries({1., 2., 3., 4., 5.},
		348	{100., 200., 300., 400., 500.})
265	<< 4.9 << true << 4.;	349	<< 4.9 << true << 4.;
266	QTest::newRow("maxData4") << createSeries({1., 2., 3., 4., 5.}, {~~100.~~, ~~200.~~, ~~300.~~, ~~400.~~, ~~500.~~})	350	QTest::newRow("maxData4") << createScalarSeries({1., 2., 3., 4., 5.},
		351	{100., 200., 300., 400., 500.})
267	<< 1.1 << true << 1.;	352	<< 1.1 << true << 1.;
268	QTest::newRow("maxData5") << createSeries({1., 2., 3., 4., 5.}, {~~100.~~, ~~200.~~, ~~300.~~, ~~400.~~, ~~500.~~})	353	QTest::newRow("maxData5") << createScalarSeries({1., 2., 3., 4., 5.},
		354	{100., 200., 300., 400., 500.})
269	<< 1. << true << 1.;	355	<< 1. << true << 1.;
270	QTest::newRow("maxData6") << createSeries({}, {}) << 1.1 << false	356	QTest::newRow("maxData6") << createScalarSeries({}, {}) << 1.1 << false
271	<< std::numeric_limits<double>::quiet_NaN();	357	<< std::numeric_limits<double>::quiet_NaN();
272	}	358	}
273		359
274	void TestDataSeries::testMaxData()	360	void TestDataSeries::testMaxXAxisData()
275	{	361	{
276	QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);	362	QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
277	QFETCH(double, max);	363	QFETCH(double, max);
@@ -279,7 +365,7 void TestDataSeries::testMaxData()
279	QFETCH(bool, expectedOK);	365	QFETCH(bool, expectedOK);
280	QFETCH(double, expectedMax);	366	QFETCH(double, expectedMax);
281		367
282	auto it = dataSeries->maxData(max);	368	auto it = dataSeries->maxXAxisData(max);
283		369
284	QCOMPARE(expectedOK, it != dataSeries->cend());	370	QCOMPARE(expectedOK, it != dataSeries->cend());
285		371
@@ -289,20 +375,20 void TestDataSeries::testMaxData()
289	}	375	}
290	}	376	}
291		377
292	void TestDataSeries::test~~Subdata~~_data()	378	void TestDataSeries::testXAxisRange_data()
293	{	379	{
294	// ////////////// //	380	// ////////////// //
295	// Test structure //	381	// Test structure //
296	// ////////////// //	382	// ////////////// //
297		383
298	// Data series to get ~~subdata~~	384	// Data series to get x-axis range
299	QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");	385	QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
300		386
301	// Min/max values	387	// Min/max values
302	QTest::addColumn<double>("min");	388	QTest::addColumn<double>("min");
303	QTest::addColumn<double>("max");	389	QTest::addColumn<double>("max");
304		390
305	// Expected values ~~after subdata~~	391	// Expected values
306	QTest::addColumn<QVector<double> >("expectedXAxisData");	392	QTest::addColumn<QVector<double> >("expectedXAxisData");
307	QTest::addColumn<QVector<double> >("expectedValuesData");	393	QTest::addColumn<QVector<double> >("expectedValuesData");
308		394
@@ -310,29 +396,37 void TestDataSeries::testSubdata_data()
310	// Test cases //	396	// Test cases //
311	// ////////// //	397	// ////////// //
312		398
313	QTest::newRow("~~subData~~1") << createSeries({1., 2., 3., 4., 5.}, {~~100.~~, ~~200.~~, ~~300.~~, ~~400.~~, ~~500.~~})	399	QTest::newRow("xAxisRange1") << createScalarSeries({1., 2., 3., 4., 5.},
314	<< -1. << 3.2 << QVector<double>{1., 2., 3.}	400	{100., 200., 300., 400., 500.})
315	<< QVector<double>{100., 200., 300.};	401	<< -1. << 3.2 << QVector<double>{1., 2., 3.}
316	QTest::newRow("subData2") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})	402	<< QVector<double>{100., 200., 300.};
317	<< 1. << 4. << QVector<double>{1., 2., 3., 4.}	403	QTest::newRow("xAxisRange2") << createScalarSeries({1., 2., 3., 4., 5.},
318	<< ~~QVector~~<~~double~~>{100., 200., 300., 400.};	404	{100., 200., 300., 400., 500.})
319	QTest::newRow("subData3") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})	405	<< 1. << 4. << QVector<double>{1., 2., 3., 4.}
320	<< 1. << ~~3.9~~ << QVector<double>{1., 2., 3.}	406	<< QVector<double>{100., 200., 300., 400.};
321	<< QVector<double>{100., 200., 300.};	407	QTest::newRow("xAxisRange3") << createScalarSeries({1., 2., 3., 4., 5.},
322	QTest::newRow("subData4") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})	408	{100., 200., 300., 400., 500.})
323	<< 0. << 0.9 << QVector<double>{} << ~~QVector~~<~~double~~>~~{};~~	409	<< 1. << 3.9 << QVector<double>{1., 2., 3.}
324	QTest::newRow("subData5") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})	410	<< QVector<double>{100., 200., 300.};
325	<< 0. << 1. << QVector<double>{1.} << QVector<double>{100.};	411	QTest::newRow("xAxisRange4") << createScalarSeries({1., 2., 3., 4., 5.},
326	QTest::newRow("subData6") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})	412	{100., 200., 300., 400., 500.})
327	<< ~~2.1~~ << 6. << QVector<double>{3., 4., 5.}	413	<< 0. << 0.9 << QVector<double>{} << QVector<double>{};
328	<< QVector<double>{300., 400., 500.};	414	QTest::newRow("xAxisRange5") << createScalarSeries({1., 2., 3., 4., 5.},
329	QTest::newRow("subData7") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})	415	{100., 200., 300., 400., 500.})
330	<< 6. << 9. << QVector<double>{} << QVector<double>{};	416	<< 0. << 1. << QVector<double>{1.} << QVector<double>{100.};
331	QTest::newRow("~~subData8~~") << createSeries({1., 2., 3., 4., 5.}, {~~100.~~, ~~200.~~, ~~300.~~, ~~400.~~, ~~500.~~})	417	QTest::newRow("xAxisRange6") << createScalarSeries({1., 2., 3., 4., 5.},
332	<< 5. << 9. << QVector<double>{5.} << QVector<double>{500.};	418	{100., 200., 300., 400., 500.})
		419	<< 2.1 << 6. << QVector<double>{3., 4., 5.}
		420	<< QVector<double>{300., 400., 500.};
		421	QTest::newRow("xAxisRange7") << createScalarSeries({1., 2., 3., 4., 5.},
		422	{100., 200., 300., 400., 500.})
		423	<< 6. << 9. << QVector<double>{} << QVector<double>{};
		424	QTest::newRow("xAxisRange8") << createScalarSeries({1., 2., 3., 4., 5.},
		425	{100., 200., 300., 400., 500.})
		426	<< 5. << 9. << QVector<double>{5.} << QVector<double>{500.};
333	}	427	}
334		428
335	void TestDataSeries::test~~Subdata~~()	429	void TestDataSeries::testXAxisRange()
336	{	430	{
337	QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);	431	QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
338	QFETCH(double, min);	432	QFETCH(double, min);
@@ -341,7 +435,7 void TestDataSeries::testSubdata()
341	QFETCH(QVector<double>, expectedXAxisData);	435	QFETCH(QVector<double>, expectedXAxisData);
342	QFETCH(QVector<double>, expectedValuesData);	436	QFETCH(QVector<double>, expectedValuesData);
343		437
344	auto bounds = dataSeries->~~subData~~(min, max);	438	auto bounds = dataSeries->xAxisRange(min, max);
345	QVERIFY(std::equal(bounds.first, bounds.second, expectedXAxisData.cbegin(),	439	QVERIFY(std::equal(bounds.first, bounds.second, expectedXAxisData.cbegin(),
346	expectedXAxisData.cend(),	440	expectedXAxisData.cend(),
347	[](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));	441	[](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
@@ -350,5 +444,77 void TestDataSeries::testSubdata()
350	[](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));	444	[](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
351	}	445	}
352		446
		447	void TestDataSeries::testValuesBoundsScalar_data()
		448	{
		449	testValuesBoundsStructure<ScalarSeries>();
		450
		451	// ////////// //
		452	// Test cases //
		453	// ////////// //
		454	auto nan = std::numeric_limits<double>::quiet_NaN();
		455
		456	QTest::newRow("scalarBounds1")
		457	<< createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 6.
		458	<< true << 100. << 500.;
		459	QTest::newRow("scalarBounds2")
		460	<< createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 2. << 4.
		461	<< true << 200. << 400.;
		462	QTest::newRow("scalarBounds3")
		463	<< createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 0.5
		464	<< false << nan << nan;
		465	QTest::newRow("scalarBounds4")
		466	<< createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 5.1 << 6.
		467	<< false << nan << nan;
		468	QTest::newRow("scalarBounds5")
		469	<< createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100. << 100.;
		470	QTest::newRow("scalarBounds6") << createScalarSeries({}, {}) << 0. << 2. << false << nan << nan;
		471
		472	// Tests with NaN values: NaN values are not included in min/max search
		473	QTest::newRow("scalarBounds7")
		474	<< createScalarSeries({1., 2., 3., 4., 5.}, {nan, 200., 300., 400., nan}) << 0. << 6.
		475	<< true << 200. << 400.;
		476	QTest::newRow("scalarBounds8")
		477	<< createScalarSeries({1., 2., 3., 4., 5.}, {nan, nan, nan, nan, nan}) << 0. << 6. << true
		478	<< std::numeric_limits<double>::quiet_NaN() << std::numeric_limits<double>::quiet_NaN();
		479	}
		480
		481	void TestDataSeries::testValuesBoundsScalar()
		482	{
		483	testValuesBounds<ScalarSeries>();
		484	}
		485
		486	void TestDataSeries::testValuesBoundsVector_data()
		487	{
		488	testValuesBoundsStructure<VectorSeries>();
		489
		490	// ////////// //
		491	// Test cases //
		492	// ////////// //
		493	auto nan = std::numeric_limits<double>::quiet_NaN();
		494
		495	QTest::newRow("vectorBounds1")
		496	<< createVectorSeries({1., 2., 3., 4., 5.}, {10., 15., 20., 13., 12.},
		497	{35., 24., 10., 9., 0.3}, {13., 14., 12., 9., 24.})
		498	<< 0. << 6. << true << 0.3 << 35.; // min/max in same component
		499	QTest::newRow("vectorBounds2")
		500	<< createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
		501	{35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
		502	<< 0. << 6. << true << 2.3 << 35.; // min/max in same entry
		503	QTest::newRow("vectorBounds3")
		504	<< createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
		505	{35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
		506	<< 2. << 3. << true << 10. << 24.;
		507
		508	// Tests with NaN values: NaN values are not included in min/max search
		509	QTest::newRow("vectorBounds4")
		510	<< createVectorSeries({1., 2.}, {nan, nan}, {nan, nan}, {nan, nan}) << 0. << 6. << true
		511	<< nan << nan;
		512	}
		513
		514	void TestDataSeries::testValuesBoundsVector()
		515	{
		516	testValuesBounds<VectorSeries>();
		517	}
		518
353	QTEST_MAIN(TestDataSeries)	519	QTEST_MAIN(TestDataSeries)
354	#include "TestDataSeries.moc"	520	#include "TestDataSeries.moc"

gui/src/Visualization/VisualizationGraphHelper.cpp +1 -1

                     // - Gets the data of the series included in the current range
                     // - 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
-                    auto subDataIts = dataSeries.subData(range.m_TStart, range.m_TEnd);
+                    auto subDataIts = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);
                     for (auto it = subDataIts.first; it != subDataIts.second; ++it) {
                         for (const auto &dataContainer : dataContainers) {
                             auto componentIndex = dataContainer.first;

General Comments 0

Write
Preview

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

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages