HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r999:bd6284620dee

Merge branch 'feature/SpectroMeshes' into develop

Alexandre Leroux -

r999:bd6284620dee

parent child

Context file:

r999:bd6284620dee

Expand all files

core/include/Data/DataSeriesUtils.h created 644 +228 0

@@ -0,0 +1,228
	1	#ifndef SCIQLOP_DATASERIESUTILS_H
	2	#define SCIQLOP_DATASERIESUTILS_H
	3
	4	#include "CoreGlobal.h"
	5
	6	#include <Data/DataSeriesIterator.h>
	7
	8	#include <cmath>
	9	#include <QLoggingCategory>
	10
	11	Q_DECLARE_LOGGING_CATEGORY(LOG_DataSeriesUtils)
	12
	13	/**
	14	* Utility class with methods for data series
	15	*/
	16	struct SCIQLOP_CORE_EXPORT DataSeriesUtils {
	17	/**
	18	* Define a meshs.
	19	*
	20	* A mesh is a regular grid representing cells of the same width (in x) and of the same height
	21	* (in y). At each mesh point is associated a value.
	22	*
	23	* Each axis of the mesh is defined by a minimum value, a number of values is a mesh step.
	24	* For example: if min = 1, nbValues = 5 and step = 2 => the axis of the mesh will be [1, 3, 5,
	25	* 7, 9].
	26	*
	27	* The values are defined in an array of size {nbX * nbY}. The data is stored along the X axis.
	28	*
	29	* For example, the mesh:
	30	* Y = 2 [ 7 ; 8 ; 9
	31	* Y = 1 4 ; 5 ; 6
	32	* Y = 0 1 ; 2 ; 3 ]
	33	* X = 0 X = 1 X = 2
	34	*
	35	* will be represented by data [1, 2, 3, 4, 5, 6, 7, 8, 9]
	36	*/
	37	struct Mesh {
	38	explicit Mesh() = default;
	39	explicit Mesh(int nbX, double xMin, double xStep, int nbY, double yMin, double yStep)
	40	: m_NbX{nbX},
	41	m_XMin{xMin},
	42	m_XStep{xStep},
	43	m_NbY{nbY},
	44	m_YMin{yMin},
	45	m_YStep{yStep},
	46	m_Data(nbX * nbY)
	47	{
	48	}
	49
	50	inline bool isEmpty() const { return m_Data.size() == 0; }
	51	inline double xMax() const { return m_XMin + (m_NbX - 1) * m_XStep; }
	52	inline double yMax() const { return m_YMin + (m_NbY - 1) * m_YStep; }
	53
	54	int m_NbX{0};
	55	double m_XMin{};
	56	double m_XStep{};
	57	int m_NbY{0};
	58	double m_YMin{};
	59	double m_YStep{};
	60	std::vector<double> m_Data{};
	61	};
	62
	63	/**
	64	* Represents a resolution used to generate the data of a mesh on the x-axis or in Y.
	65	*
	66	* A resolution is represented by a value and flag indicating if it's in the logarithmic scale
	67	* @sa Mesh
	68	*/
	69	struct Resolution {
	70	double m_Val{std::numeric_limits<double>::quiet_NaN()};
	71	bool m_Logarithmic{false};
	72	};
	73
	74	/**
	75	* Processes data from a data series to complete the data holes with a fill value.
	76	*
	77	* A data hole is determined by the resolution passed in parameter: if, between two continuous
	78	* data on the x-axis, the difference between these data is greater than the resolution, then
	79	* there is one or more holes between them. The holes are filled by adding:
	80	* - for the x-axis, new data corresponding to the 'step resolution' starting from the first
	81	* data;
	82	* - for values, a default value (fill value) for each new data added on the x-axis.
	83	*
	84	* For example, with :
	85	* - xAxisData = [0, 1, 5, 7, 14 ]
	86	* - valuesData = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] (two components per x-axis data)
	87	* - fillValue = NaN
	88	* - and resolution = 2;
	89	*
	90	* For the x axis, we calculate as data holes: [3, 9, 11, 13]. These holes are added to the
	91	* x-axis data, and NaNs (two per x-axis data) are added to the values:
	92	* => xAxisData = [0, 1, 3, 5, 7, 9, 11, 13, 14 ]
	93	* => valuesData = [0, 1, 2, 3, NaN, NaN, 4, 5, 6, 7, NaN, NaN, NaN, NaN, NaN, NaN, 8, 9]
	94	*
	95	* It is also possible to set bounds for the data series. If these bounds are defined and exceed
	96	* the limits of the data series, data holes are added to the series at the beginning and/or the
	97	* end.
	98	*
	99	* The generation of data holes at the beginning/end of the data series is performed starting
	100	* from the x-axis series limit and adding data holes at each 'resolution step' as long as the
	101	* new bound is not reached.
	102	*
	103	* For example, with :
	104	* - xAxisData = [3, 4, 5, 6, 7 ]
	105	* - valuesData = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
	106	* - fillValue = NaN
	107	* - minBound = 0
	108	* - maxBound = 12
	109	* - and resolution = 2;
	110	*
	111	* => Starting from 3 and decreasing 2 by 2 until reaching 0 : a data hole at value 1 will be
	112	* added to the beginning of the series
	113	* => Starting from 7 and increasing 2 by 2 until reaching 12 : data holes at values 9 and 11
	114	* will be added to the end of the series
	115	*
	116	* So :
	117	* => xAxisData = [1, 3, 4, 5, 6, 7, 9, 11 ]
	118	* => valuesData = [NaN, NaN, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, NaN, NaN, NaN, NaN]
	119	*
	120	* @param xAxisData the x-axis data of the data series
	121	* @param valuesData the values data of the data series
	122	* @param resolution the resoultion (on x-axis) used to determinate data holes
	123	* @param fillValue the fill value used for data holes in the values data
	124	* @param minBound the limit at which to start filling data holes for the series. If set to NaN,
	125	* the limit is not used
	126	* @param maxBound the limit at which to end filling data holes for the series. If set to NaN,
	127	* the limit is not used
	128	*
	129	* @remarks There is no control over the consistency between x-axis data and values data. The
	130	* method considers that the data is well formed (the total number of values data is a multiple
	131	* of the number of x-axis data)
	132	*/
	133	static void fillDataHoles(std::vector<double> &xAxisData, std::vector<double> &valuesData,
	134	double resolution,
	135	double fillValue = std::numeric_limits<double>::quiet_NaN(),
	136	double minBound = std::numeric_limits<double>::quiet_NaN(),
	137	double maxBound = std::numeric_limits<double>::quiet_NaN());
	138	/**
	139	* Computes the resolution of a dataset passed as a parameter.
	140	*
	141	* The resolution of a dataset is the minimum difference between two values that follow in the
	142	* set.
	143	* For example:
	144	* - for the set [0, 2, 4, 8, 10, 11, 13] => the resolution is 1 (difference between 10 and 11).
	145	*
	146	* A resolution can be calculated on the logarithmic scale (base of 10). In this case, the
	147	* dataset is first converted to logarithmic values.
	148	* For example:
	149	* - for the set [10, 100, 10000, 1000000], the values are converted to [1, 2, 4, 6] => the
	150	* logarithmic resolution is 1 (difference between 1 and 2).
	151	*
	152	* @param begin the iterator pointing to the beginning of the dataset
	153	* @param end the iterator pointing to the end of the dataset
	154	* @param logarithmic computes a logarithmic resolution or not
	155	* @return the resolution computed
	156	* @warning the method considers the dataset as sorted and doesn't control it.
	157	*/
	158	template <typename Iterator>
	159	static Resolution resolution(Iterator begin, Iterator end, bool logarithmic = false);
	160
	161	/**
	162	* Computes a regular mesh for a data series, according to resolutions for x-axis and y-axis
	163	* passed as parameters.
	164	*
	165	* The mesh is created from the resolutions in x and y and the boundaries delimiting the data
	166	* series. If the resolutions do not allow to obtain a regular mesh, they are recalculated.
	167	*
	168	* For example :
	169	* Let x-axis data = [0, 1, 3, 5, 9], its associated values = [0, 10, 30, 50, 90] and
	170	* xResolution = 2.
	171	* Based on the resolution, the mesh would be [0, 2, 4, 6, 8, 10] and would be invalid because
	172	* it exceeds the maximum bound of the data. The resolution is thus recalculated so that the
	173	* mesh holds between the data terminals.
	174	* So => resolution is 1.8 and the mesh is [0, 1.8, 3.6, 5.4, 7.2, 9].
	175	*
	176	* Once the mesh is generated in x and y, the values are associated with each mesh point,
	177	* based on the data in the series, finding the existing data at which the mesh point would be
	178	* or would be closest to, without exceeding it.
	179	*
	180	* In the example, we determine the value of each mesh point:
	181	* - x = 0 => value = 0 (existing x in the data series)
	182	* - x = 1.8 => value = 10 (the closest existing x: 1)
	183	* - x = 3.6 => value = 30 (the closest existing x: 3)
	184	* - x = 5.4 => value = 50 (the closest existing x: 5)
	185	* - x = 7.2 => value = 50 (the closest existing x: 5)
	186	* - x = 9 => value = 90 (existing x in the data series)
	187	*
	188	* Same algorithm is applied for y-axis.
	189	*
	190	* @param begin the iterator pointing to the beginning of the data series
	191	* @param end the iterator pointing to the end of the data series
	192	* @param xResolution the resolution expected for the mesh's x-axis
	193	* @param yResolution the resolution expected for the mesh's y-axis
	194	* @return the mesh created, an empty mesh if the input data do not allow to generate a regular
	195	* mesh (empty data, null resolutions, logarithmic x-axis)
	196	* @warning the method considers the dataset as sorted and doesn't control it.
	197	*/
	198	static Mesh regularMesh(DataSeriesIterator begin, DataSeriesIterator end,
	199	Resolution xResolution, Resolution yResolution);
	200	};
	201
	202	template <typename Iterator>
	203	DataSeriesUtils::Resolution DataSeriesUtils::resolution(Iterator begin, Iterator end,
	204	bool logarithmic)
	205	{
	206	// Retrieves data into a work dataset
	207	using ValueType = typename Iterator::value_type;
	208	std::vector<ValueType> values{};
	209	std::copy(begin, end, std::back_inserter(values));
	210
	211	// Converts data if logarithmic flag is activated
	212	if (logarithmic) {
	213	std::for_each(values.begin(), values.end(),
	214	[logarithmic](auto &val) { val = std::log10(val); });
	215	}
	216
	217	// Computes the differences between the values in the dataset
	218	std::adjacent_difference(values.begin(), values.end(), values.begin());
	219
	220	// Retrieves the smallest difference
	221	auto resolutionIt = std::min_element(values.begin(), values.end());
	222	auto resolution
	223	= resolutionIt != values.end() ? *resolutionIt : std::numeric_limits<double>::quiet_NaN();
	224
	225	return Resolution{resolution, logarithmic};
	226	}
	227
	228	#endif // SCIQLOP_DATASERIESUTILS_H

core/src/Data/DataSeriesUtils.cpp created 644 +194 0

@@ -0,0 +1,194
	1	#include "Data/DataSeriesUtils.h"
	2
	3	Q_LOGGING_CATEGORY(LOG_DataSeriesUtils, "DataSeriesUtils")
	4
	5	void DataSeriesUtils::fillDataHoles(std::vector<double> &xAxisData, std::vector<double> &valuesData,
	6	double resolution, double fillValue, double minBound,
	7	double maxBound)
	8	{
	9	if (resolution == 0. \|\| std::isnan(resolution)) {
	10	qCWarning(LOG_DataSeriesUtils())
	11	<< "Can't fill data holes with a null resolution, no changes will be made";
	12	return;
	13	}
	14
	15	if (xAxisData.empty()) {
	16	qCWarning(LOG_DataSeriesUtils())
	17	<< "Can't fill data holes for empty data, no changes will be made";
	18	return;
	19	}
	20
	21	// Gets the number of values per x-axis data
	22	auto nbComponents = valuesData.size() / xAxisData.size();
	23
	24	// Generates fill values that will be used to complete values data
	25	std::vector<double> fillValues(nbComponents, fillValue);
	26
	27	// Checks if there are data holes on the beginning of the data and generates the hole at the
	28	// extremity if it's the case
	29	auto minXAxisData = xAxisData.front();
	30	if (!std::isnan(minBound) && minBound < minXAxisData) {
	31	auto holeSize = static_cast<int>((minXAxisData - minBound) / resolution);
	32	if (holeSize > 0) {
	33	xAxisData.insert(xAxisData.begin(), minXAxisData - holeSize * resolution);
	34	valuesData.insert(valuesData.begin(), fillValues.begin(), fillValues.end());
	35	}
	36	}
	37
	38	// Same for the end of the data
	39	auto maxXAxisData = xAxisData.back();
	40	if (!std::isnan(maxBound) && maxBound > maxXAxisData) {
	41	auto holeSize = static_cast<int>((maxBound - maxXAxisData) / resolution);
	42	if (holeSize > 0) {
	43	xAxisData.insert(xAxisData.end(), maxXAxisData + holeSize * resolution);
	44	valuesData.insert(valuesData.end(), fillValues.begin(), fillValues.end());
	45	}
	46	}
	47
	48	// Generates other data holes
	49	auto xAxisIt = xAxisData.begin();
	50	while (xAxisIt != xAxisData.end()) {
	51	// Stops at first value which has a gap greater than resolution with the value next to it
	52	xAxisIt = std::adjacent_find(
	53	xAxisIt, xAxisData.end(),
	54	[resolution](const auto &a, const auto &b) { return (b - a) > resolution; });
	55
	56	if (xAxisIt != xAxisData.end()) {
	57	auto nextXAxisIt = xAxisIt + 1;
	58
	59	// Gets the values that has a gap greater than resolution between them
	60	auto lowValue = *xAxisIt;
	61	auto highValue = *nextXAxisIt;
	62
	63	// Completes holes between the two values by creating new values (according to the
	64	// resolution)
	65	for (auto i = lowValue + resolution; i < highValue; i += resolution) {
	66	// Gets the iterator of values data from which to insert fill values
	67	auto nextValuesIt = valuesData.begin()
	68	+ std::distance(xAxisData.begin(), nextXAxisIt) * nbComponents;
	69
	70	// New value is inserted before nextXAxisIt
	71	nextXAxisIt = xAxisData.insert(nextXAxisIt, i) + 1;
	72
	73	// New values are inserted before nextValuesIt
	74	valuesData.insert(nextValuesIt, fillValues.begin(), fillValues.end());
	75	}
	76
	77	// Moves to the next value to continue loop on the x-axis data
	78	xAxisIt = nextXAxisIt;
	79	}
	80	}
	81	}
	82
	83	namespace {
	84
	85	/**
	86	* Generates axis's mesh properties according to data and resolution
	87	* @param begin the iterator pointing to the beginning of the data
	88	* @param end the iterator pointing to the end of the data
	89	* @param fun the function to retrieve data from the data iterators
	90	* @param resolution the resolution to use for the axis' mesh
	91	* @return a tuple representing the mesh properties : <nb values, min value, value step>
	92	*/
	93	template <typename Iterator, typename IteratorFun>
	94	std::tuple<int, double, double> meshProperties(Iterator begin, Iterator end, IteratorFun fun,
	95	double resolution)
	96	{
	97	// Computes the gap between min and max data. This will be used to determinate the step between
	98	// each data of the mesh
	99	auto min = fun(begin);
	100	auto max = fun(end - 1);
	101	auto gap = max - min;
	102
	103	// Computes the step trying to use the fixed resolution. If the resolution doesn't separate the
	104	// values evenly , it is recalculated.
	105	// For example, for a resolution of 2.0:
	106	// - for interval [0; 8] => resolution is valid, the generated mesh will be [0, 2, 4, 6, 8]
	107	// - for interval [0; 9] => it's impossible to create a regular mesh with this resolution
	108	// The resolution is recalculated and is worth 1.8. The generated mesh will be [0, 1.8, 3.6,
	109	// 5.4, 7.2, 9]
	110	auto nbVal = static_cast<int>(std::ceil(gap / resolution));
	111	auto step = gap / nbVal;
	112
	113	// last data is included in the total number of values
	114	return std::make_tuple(nbVal + 1, min, step);
	115	}
	116
	117	} // namespace
	118
	119	DataSeriesUtils::Mesh DataSeriesUtils::regularMesh(DataSeriesIterator begin, DataSeriesIterator end,
	120	Resolution xResolution, Resolution yResolution)
	121	{
	122	// Checks preconditions
	123	if (xResolution.m_Val == 0. \|\| std::isnan(xResolution.m_Val) \|\| yResolution.m_Val == 0.
	124	\|\| std::isnan(yResolution.m_Val)) {
	125	qCWarning(LOG_DataSeriesUtils()) << "Can't generate mesh with a null resolution";
	126	return Mesh{};
	127	}
	128
	129	if (xResolution.m_Logarithmic) {
	130	qCWarning(LOG_DataSeriesUtils())
	131	<< "Can't generate mesh with a logarithmic x-axis resolution";
	132	return Mesh{};
	133	}
	134
	135	if (std::distance(begin, end) == 0) {
	136	qCWarning(LOG_DataSeriesUtils()) << "Can't generate mesh for empty data";
	137	return Mesh{};
	138	}
	139
	140	auto yData = begin->y();
	141	if (yData.empty()) {
	142	qCWarning(LOG_DataSeriesUtils()) << "Can't generate mesh for data with no y-axis";
	143	return Mesh{};
	144	}
	145
	146	// Converts y-axis and its resolution to logarithmic values
	147	if (yResolution.m_Logarithmic) {
	148	std::for_each(yData.begin(), yData.end(), [](auto &val) { val = std::log10(val); });
	149	}
	150
	151	// Computes mesh properties
	152	int nbX, nbY;
	153	double xMin, xStep, yMin, yStep;
	154	std::tie(nbX, xMin, xStep)
	155	= meshProperties(begin, end, [](const auto &it) { return it->x(); }, xResolution.m_Val);
	156	std::tie(nbY, yMin, yStep) = meshProperties(
	157	yData.begin(), yData.end(), [](const auto &it) { return *it; }, yResolution.m_Val);
	158
	159	// Generates mesh according to the x-axis and y-axis steps
	160	Mesh result{nbX, xMin, xStep, nbY, yMin, yStep};
	161
	162	for (auto meshXIndex = 0; meshXIndex < nbX; ++meshXIndex) {
	163	auto meshX = xMin + meshXIndex * xStep;
	164	// According to current x-axis of the mesh, finds in the data series the interval in which
	165	// the data is or gets closer (without exceeding it).
	166	// An interval is defined by a value and extends to +/- 50% of the resolution. For example,
	167	// for a value of 3 and a resolution of 1, the associated interval is [2.5, 3.5].
	168	auto xIt = std::lower_bound(begin, end, meshX,
	169	[xResolution](const auto &it, const auto &val) {
	170	return it.x() - xResolution.m_Val / 2. < val;
	171	})
	172	- 1;
	173
	174	// When the corresponding entry of the data series is found, generates the values of the
	175	// mesh by retrieving the values of the entry, for each y-axis value of the mesh
	176	auto values = xIt->values();
	177
	178	for (auto meshYIndex = 0; meshYIndex < nbY; ++meshYIndex) {
	179	auto meshY = yMin + meshYIndex * yStep;
	180
	181	auto yBegin = yData.begin();
	182	auto yIt = std::lower_bound(yBegin, yData.end(), meshY,
	183	[yResolution](const auto &it, const auto &val) {
	184	return it - yResolution.m_Val / 2. < val;
	185	})
	186	- 1;
	187
	188	auto valueIndex = std::distance(yBegin, yIt);
	189	result.m_Data[result.m_NbX * meshYIndex + meshXIndex] = values.at(valueIndex);
	190	}
	191	}
	192
	193	return result;
	194	}

core/tests/Data/TestDataSeriesUtils.cpp created 644 +108 0

@@ -0,0 +1,108
	1	#include <Data/DataSeriesUtils.h>
	2
	3	#include <QObject>
	4	#include <QtTest>
	5
	6	class TestDataSeriesUtils : public QObject {
	7	Q_OBJECT
	8
	9	private slots:
	10	/// Tests @sa DataSeriesUtils::fillDataHoles() method
	11	void testFillDataHoles_data();
	12	void testFillDataHoles();
	13	};
	14
	15	void TestDataSeriesUtils::testFillDataHoles_data()
	16	{
	17	QTest::addColumn<std::vector<double> >("xAxisData");
	18	QTest::addColumn<std::vector<double> >("valuesData");
	19	QTest::addColumn<double>("resolution");
	20	QTest::addColumn<double>("fillValue");
	21	QTest::addColumn<double>("minBound");
	22	QTest::addColumn<double>("maxBound");
	23	QTest::addColumn<std::vector<double> >(
	24	"expectedXAxisData"); // expected x-axis data after filling holes
	25	QTest::addColumn<std::vector<double> >(
	26	"expectedValuesData"); // expected values data after filling holes
	27
	28	auto nan = std::numeric_limits<double>::quiet_NaN();
	29
	30	QTest::newRow("fillDataHoles (basic case)")
	31	<< std::vector<double>{0., 1., 5., 7., 14.} << std::vector<double>{0., 1., 2., 3., 4.} << 2.
	32	<< nan << nan << nan << std::vector<double>{0., 1., 3., 5., 7., 9., 11., 13., 14.}
	33	<< std::vector<double>{0., 1., nan, 2., 3., nan, nan, nan, 4.};
	34
	35	QTest::newRow("fillDataHoles (change nb components)")
	36	<< std::vector<double>{0., 1., 5., 7., 14.}
	37	<< std::vector<double>{0., 1., 2., 3., 4., 5., 6., 7., 8., 9.} << 2. << nan << nan << nan
	38	<< std::vector<double>{0., 1., 3., 5., 7., 9., 11., 13., 14.}
	39	<< std::vector<double>{0., 1., 2., 3., nan, nan, 4., 5., 6.,
	40	7., nan, nan, nan, nan, nan, nan, 8., 9.};
	41
	42	QTest::newRow("fillDataHoles (change resolution)")
	43	<< std::vector<double>{0., 1., 5., 7., 14.} << std::vector<double>{0., 1., 2., 3., 4.}
	44	<< 1.5 << nan << nan << nan
	45	<< std::vector<double>{0., 1., 2.5, 4., 5., 6.5, 7., 8.5, 10., 11.5, 13., 14.}
	46	<< std::vector<double>{0., 1., nan, nan, 2., nan, 3., nan, nan, nan, nan, 4.};
	47
	48	QTest::newRow("fillDataHoles (with no data (no changes made))")
	49	<< std::vector<double>{} << std::vector<double>{} << 2. << nan << nan << nan
	50	<< std::vector<double>{} << std::vector<double>{};
	51
	52	QTest::newRow("fillDataHoles (with no resolution (no changes made))")
	53	<< std::vector<double>{0., 1., 5., 7., 14.} << std::vector<double>{0., 1., 2., 3., 4.} << 0.
	54	<< nan << nan << nan << std::vector<double>{0., 1., 5., 7., 14.}
	55	<< std::vector<double>{0., 1., 2., 3., 4.};
	56
	57	QTest::newRow("fillDataHoles (change fill value)")
	58	<< std::vector<double>{0., 1., 5., 7., 14.} << std::vector<double>{0., 1., 2., 3., 4.} << 2.
	59	<< -1. << nan << nan << std::vector<double>{0., 1., 3., 5., 7., 9., 11., 13., 14.}
	60	<< std::vector<double>{0., 1., -1., 2., 3., -1., -1., -1., 4.};
	61
	62	QTest::newRow("fillDataHoles (add data holes to the beginning)")
	63	<< std::vector<double>{5., 7., 9., 11., 13.} << std::vector<double>{0., 1., 2., 3., 4.}
	64	<< 2. << nan << 0. << nan << std::vector<double>{1., 3., 5., 7., 9., 11., 13.}
	65	<< std::vector<double>{nan, nan, 0., 1., 2., 3., 4.};
	66
	67	QTest::newRow("fillDataHoles (add data holes to the end)")
	68	<< std::vector<double>{5., 7., 9., 11., 13.} << std::vector<double>{0., 1., 2., 3., 4.}
	69	<< 2. << nan << nan << 21. << std::vector<double>{5., 7., 9., 11., 13., 15., 17., 19., 21.}
	70	<< std::vector<double>{0., 1., 2., 3., 4., nan, nan, nan, nan};
	71
	72	QTest::newRow("fillDataHoles (invalid min/max bounds (no changes made))")
	73	<< std::vector<double>{5., 7., 9., 11., 13.} << std::vector<double>{0., 1., 2., 3., 4.}
	74	<< 2. << nan << 8. << 13. << std::vector<double>{5., 7., 9., 11., 13.}
	75	<< std::vector<double>{0., 1., 2., 3., 4.};
	76	}
	77
	78	void TestDataSeriesUtils::testFillDataHoles()
	79	{
	80	QFETCH(std::vector<double>, xAxisData);
	81	QFETCH(std::vector<double>, valuesData);
	82	QFETCH(double, resolution);
	83	QFETCH(double, fillValue);
	84	QFETCH(double, minBound);
	85	QFETCH(double, maxBound);
	86
	87	QFETCH(std::vector<double>, expectedXAxisData);
	88	QFETCH(std::vector<double>, expectedValuesData);
	89
	90	// Executes method (xAxisData and valuesData are modified)
	91	DataSeriesUtils::fillDataHoles(xAxisData, valuesData, resolution, fillValue, minBound,
	92	maxBound);
	93
	94	// Checks results
	95	auto equal = [](const auto &data, const auto &expectedData) {
	96	// Compares with NaN values
	97	return std::equal(data.begin(), data.end(), expectedData.begin(), expectedData.end(),
	98	[](const auto &val, const auto &expectedVal) {
	99	return (std::isnan(val) && std::isnan(expectedVal))
	100	\|\| val == expectedVal;
	101	});
	102	};
	103	QVERIFY(equal(xAxisData, expectedXAxisData));
	104	QVERIFY(equal(valuesData, expectedValuesData));
	105	}
	106
	107	QTEST_MAIN(TestDataSeriesUtils)
	108	#include "TestDataSeriesUtils.moc"

plugins/amda/tests-resources/TestAmdaResultParser/spectro/ValidSpectrogramDataHoles.txt created 644 +62 0

@@ -0,0 +1,62
	1	# -----------
	2	# AMDA INFO :
	3	# -----------
	4	# AMDA_ABOUT : Created by CDPP/AMDA(c)
	5	# AMDA_VERSION : 3.5.0
	6	# AMDA_ACKNOWLEDGEMENT : CDPP/AMDA Team
	7	#
	8	# --------------
	9	# REQUEST INFO :
	10	# --------------
	11	# REQUEST_STRUCTURE : one-file-per-parameter-per-interval
	12	# REQUEST_TIME_FORMAT : ISO 8601
	13	# REQUEST_OUTPUT_PARAMS : tha_ion_sp
	14	#
	15	# -----------------
	16	# BASE PARAMETERS :
	17	# -----------------
	18	#
	19	# MISSION_ID : NONE
	20	#
	21	# INSTRUMENT_ID : NONE
	22	#
	23	# DATASET_ID : tha-esa-l2i
	24	# DATASET_NAME : ion full mode
	25	# DATASET_SOURCE : CDPP/DDServer
	26	# DATASET_GLOBAL_START : 2007-03-07T18:53:59.134
	27	# DATASET_GLOBAL_STOP : 2017-11-04T18:35:25.907
	28	# DATASET_MIN_SAMPLING : 96
	29	# DATASET_MAX_SAMPLING : 180
	30	#
	31	# PARAMETER_ID : tha_ion_sp
	32	# PARAMETER_NAME : tha_ion_sp
	33	# PARAMETER_SHORT_NAME : spectra
	34	# PARAMETER_UNITS : eV/(cm^2-s-sr-eV)
	35	# PARAMETER_TENSOR_ORDER : 0
	36	# PARAMETER_TABLE[0] : energy
	37	# PARAMETER_TABLE_UNITS[0] : eV
	38	# PARAMETER_TABLE_MIN_VALUES[0] : 14234.4,18737.3
	39	# PARAMETER_TABLE_MAX_VALUES[0] : 18737.3,23254.9
	40	# PARAMETER_FILL_VALUE : nan
	41	# PARAMETER_UCD : phys.flux.density;phys.energy;phys.atmol.ionStage
	42	#
	43	#
	44	# ---------------
	45	# INTERVAL INFO :
	46	# ---------------
	47	# INTERVAL_START : 2011-12-10T12:10:00.000
	48	# INTERVAL_STOP : 2011-12-10T12:40:00.000
	49	#
	50	# ------
	51	# DATA :
	52	# ------
	53	# DATA_COLUMNS : AMDA_TIME, tha_ion_sp[0], tha_ion_sp[1]
	54	#
	55	2011-12-10T12:10:54.000 2577578.000 2336016.000
	56	2011-12-10T12:17:23.000 2314121.500 1712093.125
	57	2011-12-10T12:23:51.000 2063608.750 1614491.625
	58	2011-12-10T12:30:19.000 2234525.500 1764516.500
	59	2011-12-10T12:35:04.000 1670215.250 1688078.500
	60	2011-12-10T12:36:41.000 1689243.250 1743183.500
	61	2011-12-10T12:38:18.000 1654617.125 1733603.250
	62	2011-12-10T12:39:55.000 1504983.750 1708356.500 No newline at end of file

plugins/amda/tests-resources/TestAmdaResultParser/spectro/ValidSpectrogramDataHoles2.txt created 644 +62 0

@@ -0,0 +1,62
	1	# -----------
	2	# AMDA INFO :
	3	# -----------
	4	# AMDA_ABOUT : Created by CDPP/AMDA(c)
	5	# AMDA_VERSION : 3.5.0
	6	# AMDA_ACKNOWLEDGEMENT : CDPP/AMDA Team
	7	#
	8	# --------------
	9	# REQUEST INFO :
	10	# --------------
	11	# REQUEST_STRUCTURE : one-file-per-parameter-per-interval
	12	# REQUEST_TIME_FORMAT : ISO 8601
	13	# REQUEST_OUTPUT_PARAMS : tha_ion_sp
	14	#
	15	# -----------------
	16	# BASE PARAMETERS :
	17	# -----------------
	18	#
	19	# MISSION_ID : NONE
	20	#
	21	# INSTRUMENT_ID : NONE
	22	#
	23	# DATASET_ID : tha-esa-l2i
	24	# DATASET_NAME : ion full mode
	25	# DATASET_SOURCE : CDPP/DDServer
	26	# DATASET_GLOBAL_START : 2007-03-07T18:53:59.134
	27	# DATASET_GLOBAL_STOP : 2017-11-04T18:35:25.907
	28	# DATASET_MIN_SAMPLING : 96
	29	# DATASET_MAX_SAMPLING : 240
	30	#
	31	# PARAMETER_ID : tha_ion_sp
	32	# PARAMETER_NAME : tha_ion_sp
	33	# PARAMETER_SHORT_NAME : spectra
	34	# PARAMETER_UNITS : eV/(cm^2-s-sr-eV)
	35	# PARAMETER_TENSOR_ORDER : 0
	36	# PARAMETER_TABLE[0] : energy
	37	# PARAMETER_TABLE_UNITS[0] : eV
	38	# PARAMETER_TABLE_MIN_VALUES[0] : 14234.4,18737.3
	39	# PARAMETER_TABLE_MAX_VALUES[0] : 18737.3,23254.9
	40	# PARAMETER_FILL_VALUE : nan
	41	# PARAMETER_UCD : phys.flux.density;phys.energy;phys.atmol.ionStage
	42	#
	43	#
	44	# ---------------
	45	# INTERVAL INFO :
	46	# ---------------
	47	# INTERVAL_START : 2011-12-10T12:00:00.000
	48	# INTERVAL_STOP : 2011-12-10T13:00:00.000
	49	#
	50	# ------
	51	# DATA :
	52	# ------
	53	# DATA_COLUMNS : AMDA_TIME, tha_ion_sp[0], tha_ion_sp[1]
	54	#
	55	2011-12-10T12:10:54.000 2577578.000 2336016.000
	56	2011-12-10T12:17:23.000 2314121.500 1712093.125
	57	2011-12-10T12:23:51.000 2063608.750 1614491.625
	58	2011-12-10T12:30:19.000 2234525.500 1764516.500
	59	2011-12-10T12:35:04.000 1670215.250 1688078.500
	60	2011-12-10T12:36:41.000 1689243.250 1743183.500
	61	2011-12-10T12:38:18.000 1654617.125 1733603.250
	62	2011-12-10T12:39:55.000 1504983.750 1708356.500 No newline at end of file

core/include/Data/DataSeries.h +29 -5

             #ifndef SCIQLOP_DATASERIES_H
             #define SCIQLOP_DATASERIES_H
             #include "CoreGlobal.h"
             #include <Common/SortUtils.h>
             #include <Data/ArrayData.h>
             #include <Data/DataSeriesMergeHelper.h>
             #include <Data/IDataSeries.h>
             #include <Data/OptionalAxis.h>
             #include <QLoggingCategory>
             #include <QReadLocker>
             #include <QReadWriteLock>
             #include <memory>
             // We don't use the Qt macro since the log is used in the header file, which causes multiple log
             // definitions with inheritance. Inline method is used instead
             inline const QLoggingCategory &LOG_DataSeries()
             {
                 static const QLoggingCategory category{"DataSeries"};
                 return category;
             }
             template <int Dim>
             class DataSeries;
             namespace dataseries_detail {
             template <int Dim, bool IsConst>
             class IteratorValue : public DataSeriesIteratorValue::Impl {
             public:
                 friend class DataSeries<Dim>;
                 template <bool IC = IsConst, typename = std::enable_if_t<IC == false> >
                 explicit IteratorValue(DataSeries<Dim> &dataSeries, bool begin)
                         : m_XIt(begin ? dataSeries.xAxisData()->begin() : dataSeries.xAxisData()->end()),
-                          m_ValuesIt(begin ? dataSeries.valuesData()->begin() : dataSeries.valuesData()->end())
+                          m_ValuesIt(begin ? dataSeries.valuesData()->begin() : dataSeries.valuesData()->end()),
+                          m_YItBegin{dataSeries.yAxis().begin()},
+                          m_YItEnd{dataSeries.yAxis().end()}
                 {
                 }
                 template <bool IC = IsConst, typename = std::enable_if_t<IC == true> >
                 explicit IteratorValue(const DataSeries<Dim> &dataSeries, bool begin)
                         : m_XIt(begin ? dataSeries.xAxisData()->cbegin() : dataSeries.xAxisData()->cend()),
                           m_ValuesIt(begin ? dataSeries.valuesData()->cbegin()
-                                           : dataSeries.valuesData()->cend())
+                                           : dataSeries.valuesData()->cend()),
+                          m_YItBegin{dataSeries.yAxis().cbegin()},
+                          m_YItEnd{dataSeries.yAxis().cend()}
                 {
                 }
                 IteratorValue(const IteratorValue &other) = default;
                 std::unique_ptr<DataSeriesIteratorValue::Impl> clone() const override
                 {
                     return std::make_unique<IteratorValue<Dim, IsConst> >(*this);
                 }
                 int distance(const DataSeriesIteratorValue::Impl &other) const override try {
                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
                     return m_XIt->distance(*otherImpl.m_XIt);
                 }
                 catch (const std::bad_cast &) {
                     return 0;
                 }
                 bool equals(const DataSeriesIteratorValue::Impl &other) const override try {
                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
-                    return std::tie(m_XIt, m_ValuesIt) == std::tie(otherImpl.m_XIt, otherImpl.m_ValuesIt);
+                    return std::tie(m_XIt, m_ValuesIt, m_YItBegin, m_YItEnd)
+                           == std::tie(otherImpl.m_XIt, otherImpl.m_ValuesIt, otherImpl.m_YItBegin,
+                                       otherImpl.m_YItEnd);
                 }
                 catch (const std::bad_cast &) {
                     return false;
                 }
                 bool lowerThan(const DataSeriesIteratorValue::Impl &other) const override try {
                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
                     return m_XIt->lowerThan(*otherImpl.m_XIt);
                 }
                 catch (const std::bad_cast &) {
                     return false;
                 }
                 std::unique_ptr<DataSeriesIteratorValue::Impl> advance(int offset) const override
                 {
                     auto result = clone();
                     result->next(offset);
                     return result;
                 }
                 void next(int offset) override
                 {
                     m_XIt->next(offset);
                     m_ValuesIt->next(offset);
                 }
                 void prev() override
                 {
                     --m_XIt;
                     --m_ValuesIt;
                 }
                 double x() const override { return m_XIt->at(0); }
+                std::vector<double> y() const override
+                {
+                    std::vector<double> result{};
+                    std::transform(m_YItBegin, m_YItEnd, std::back_inserter(result),
+                                   [](const auto &it) { return it.first(); });
+                    return result;
+                }
                 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(); }
                 QVector<double> values() const override { return m_ValuesIt->values(); }
                 void swap(DataSeriesIteratorValue::Impl &other) override
                 {
                     auto &otherImpl = dynamic_cast<IteratorValue &>(other);
                     m_XIt->impl()->swap(*otherImpl.m_XIt->impl());
                     m_ValuesIt->impl()->swap(*otherImpl.m_ValuesIt->impl());
+                    m_YItBegin->impl()->swap(*otherImpl.m_YItBegin->impl());
+                    m_YItEnd->impl()->swap(*otherImpl.m_YItEnd->impl());
                 }
             private:
                 ArrayDataIterator m_XIt;
                 ArrayDataIterator m_ValuesIt;
+                ArrayDataIterator m_YItBegin;
+                ArrayDataIterator m_YItEnd;
             };
             } // namespace dataseries_detail
             /**
              * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
              *
              * The DataSeries represents values on one or two axes, according to these rules:
              * - the x-axis is always defined
              * - an y-axis can be defined or not. If set, additional consistency checks apply to the values (see
              * below)
              * - the values are defined on one or two dimensions. In the case of 2-dim values, the data is
              * distributed into components (for example, a vector defines three components)
              * - New values can be added to the series, on the x-axis.
              * - Once initialized to the series creation, the y-axis (if defined) is no longer modifiable
              * - Data representing values and axes are associated with a unit
              * - The data series is always sorted in ascending order on the x-axis.
              *
              * Consistency checks are carried out between the axes and the values. These controls are provided
              * throughout the DataSeries lifecycle:
              * - the number of data on the x-axis must be equal to the number of values (in the case of
              * 2-dim ArrayData for values, the test is performed on the number of values per component)
              * - if the y-axis is defined, the number of components of the ArrayData for values must equal the
              * number of data on the y-axis.
              *
              * Examples:
              * 1)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: not defined
              * - values: [10 ; 20 ; 30] (1-dim ArrayData)
              * => the DataSeries is valid, as x-axis and values have the same number of data
              *
              * 2)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: not defined
              * - values: [10 ; 20 ; 30 ; 40] (1-dim ArrayData)
              * => the DataSeries is invalid, as x-axis and values haven't the same number of data
              *
              * 3)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: not defined
              * - values: [10 ; 20 ; 30
              *            40 ; 50 ; 60] (2-dim ArrayData)
              * => the DataSeries is valid, as x-axis has 3 data and values contains 2 components with 3
              * data each
              *
              * 4)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: [1 ; 2]
              * - values: [10 ; 20 ; 30
              *            40 ; 50 ; 60] (2-dim ArrayData)
              * => the DataSeries is valid, as:
              * - x-axis has 3 data and values contains 2 components with 3 data each AND
              * - y-axis has 2 data and values contains 2 components
              *
              * 5)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: [1 ; 2 ; 3]
              * - values: [10 ; 20 ; 30
              *            40 ; 50 ; 60] (2-dim ArrayData)
              * => the DataSeries is invalid, as:
              * - x-axis has 3 data and values contains 2 components with 3 data each BUT
              * - y-axis has 3 data and values contains only 2 components
              *
              * @tparam Dim The dimension of the values data
              *
              */
             template <int Dim>
             class SCIQLOP_CORE_EXPORT DataSeries : public IDataSeries {
                 friend class DataSeriesMergeHelper;
             public:
                 /// @sa IDataSeries::xAxisData()
                 std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
                 const std::shared_ptr<ArrayData<1> > xAxisData() const { return m_XAxisData; }
                 /// @sa IDataSeries::xAxisUnit()
                 Unit xAxisUnit() const override { return m_XAxisUnit; }
+                /// @sa IDataSeries::yAxisUnit()
+                Unit yAxisUnit() const override { return m_YAxis.unit(); }
                 /// @return the values dataset
                 std::shared_ptr<ArrayData<Dim> > valuesData() { return m_ValuesData; }
                 const std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
                 /// @sa IDataSeries::valuesUnit()
                 Unit valuesUnit() const override { return m_ValuesUnit; }
                 int nbPoints() const override { return m_ValuesData->totalSize(); }
+                std::pair<double, double> yBounds() const override { return m_YAxis.bounds(); }
                 void clear()
                 {
                     m_XAxisData->clear();
                     m_ValuesData->clear();
                 }
                 bool isEmpty() const noexcept { return m_XAxisData->size() == 0; }
                 /// Merges into the data series an other data series.
                 ///
                 /// The two dataseries:
                 /// - must be of the same dimension
                 /// - must have the same y-axis (if defined)
                 ///
                 /// If the prerequisites are not valid, the method does nothing
                 ///
                 /// @remarks the data series to merge with is cleared after the operation
                 void merge(IDataSeries *dataSeries) override
                 {
                     dataSeries->lockWrite();
                     lockWrite();
                     if (auto other = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
                         if (m_YAxis == other->m_YAxis) {
                             DataSeriesMergeHelper::merge(*other, *this);
                         }
                         else {
                             qCWarning(LOG_DataSeries())
                                 << QObject::tr("Can't merge data series that have not the same y-axis");
                         }
                     }
                     else {
                         qCWarning(LOG_DataSeries())
                             << QObject::tr("Detection of a type of IDataSeries we cannot merge with !");
                     }
                     unlock();
                     dataSeries->unlock();
                 }
                 void purge(double min, double max) override
                 {
                     // Nothing to purge if series is empty
                     if (isEmpty()) {
                         return;
                     }
                     if (min > max) {
                         std::swap(min, max);
                     }
                     // Nothing to purge if series min/max are inside purge range
                     auto xMin = cbegin()->x();
                     auto xMax = (--cend())->x();
                     if (xMin >= min && xMax <= max) {
                         return;
                     }
                     auto lowerIt = std::lower_bound(
                         begin(), end(), min, [](const auto &it, const auto &val) { return it.x() < val; });
                     erase(begin(), lowerIt);
                     auto upperIt = std::upper_bound(
                         begin(), end(), max, [](const auto &val, const auto &it) { return val < it.x(); });
                     erase(upperIt, end());
                 }
                 // ///////// //
                 // Iterators //
                 // ///////// //
                 DataSeriesIterator begin() override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim, false> >(*this, true)}};
                 }
                 DataSeriesIterator end() override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim, false> >(*this, false)}};
                 }
                 DataSeriesIterator cbegin() const override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim, true> >(*this, true)}};
                 }
                 DataSeriesIterator cend() const override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim, true> >(*this, false)}};
                 }
                 void erase(DataSeriesIterator first, DataSeriesIterator last)
                 {
                     auto firstImpl
                         = dynamic_cast<dataseries_detail::IteratorValue<Dim, false> *>(first->impl());
                     auto lastImpl = dynamic_cast<dataseries_detail::IteratorValue<Dim, false> *>(last->impl());
                     if (firstImpl && lastImpl) {
                         m_XAxisData->erase(firstImpl->m_XIt, lastImpl->m_XIt);
                         m_ValuesData->erase(firstImpl->m_ValuesIt, lastImpl->m_ValuesIt);
                     }
                 }
                 void insert(DataSeriesIterator first, DataSeriesIterator last, bool prepend = false)
                 {
                     auto firstImpl = dynamic_cast<dataseries_detail::IteratorValue<Dim, true> *>(first->impl());
                     auto lastImpl = dynamic_cast<dataseries_detail::IteratorValue<Dim, true> *>(last->impl());
                     if (firstImpl && lastImpl) {
                         m_XAxisData->insert(firstImpl->m_XIt, lastImpl->m_XIt, prepend);
                         m_ValuesData->insert(firstImpl->m_ValuesIt, lastImpl->m_ValuesIt, prepend);
                     }
                 }
                 /// @sa IDataSeries::minXAxisData()
                 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::maxXAxisData()
                 DataSeriesIterator maxXAxisData(double maxXAxisData) const override
                 {
                     // Gets the first element that greater than max value
                     auto it = std::upper_bound(
                         cbegin(), cend(), maxXAxisData,
                         [](const auto &value, const auto &itValue) { return value < itValue.x(); });
                     return it == cbegin() ? cend() : --it;
                 }
                 std::pair<DataSeriesIterator, DataSeriesIterator> xAxisRange(double minXAxisData,
                                                                              double maxXAxisData) const override
                 {
                     if (minXAxisData > maxXAxisData) {
                         std::swap(minXAxisData, maxXAxisData);
                     }
                     auto begin = cbegin();
                     auto end = cend();
                     auto lowerIt = std::lower_bound(
                         begin, end, minXAxisData,
                         [](const auto &itValue, const auto &value) { return itValue.x() < value; });
                     auto upperIt = std::upper_bound(
                         lowerIt, end, maxXAxisData,
                         [](const auto &value, const auto &itValue) { 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);
                 }
                 /// @return the y-axis associated to the data series
-                /// @todo pass getter as protected and use iterators to access the y-axis data
+                const OptionalAxis &yAxis() const { return m_YAxis; }
-                OptionalAxis yAxis() const { return m_YAxis; }
+                OptionalAxis &yAxis() { return m_YAxis; }
                 // /////// //
                 // Mutexes //
                 // /////// //
                 virtual void lockRead() { m_Lock.lockForRead(); }
                 virtual void lockWrite() { m_Lock.lockForWrite(); }
                 virtual void unlock() { m_Lock.unlock(); }
             protected:
                 /// Protected ctor (DataSeries is abstract).
                 ///
                 /// Data vectors must be consistent with each other, otherwise an exception will be thrown (@sa
                 /// class description for consistent rules)
                 /// @remarks data series is automatically sorted on its x-axis data
                 /// @throws std::invalid_argument if the data are inconsistent with each other
                 explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
                                     std::shared_ptr<ArrayData<Dim> > valuesData, const Unit &valuesUnit,
                                     OptionalAxis yAxis = OptionalAxis{})
                         : m_XAxisData{xAxisData},
                           m_XAxisUnit{xAxisUnit},
                           m_ValuesData{valuesData},
                           m_ValuesUnit{valuesUnit},
                           m_YAxis{std::move(yAxis)}
                 {
                     if (m_XAxisData->size() != m_ValuesData->size()) {
                         throw std::invalid_argument{
                             "The number of values by component must be equal to the number of x-axis data"};
                     }
                     // Validates y-axis (if defined)
                     if (yAxis.isDefined() && (yAxis.size() != m_ValuesData->componentCount())) {
                         throw std::invalid_argument{
                             "As the y-axis is defined, the number of value components must be equal to the "
                             "number of y-axis data"};
                     }
                     // Sorts data if it's not the case
                     const auto &xAxisCData = m_XAxisData->cdata();
                     if (!std::is_sorted(xAxisCData.cbegin(), xAxisCData.cend())) {
                         sort();
                     }
                 }
                 /// Copy ctor
                 explicit DataSeries(const DataSeries<Dim> &other)
                         : m_XAxisData{std::make_shared<ArrayData<1> >(*other.m_XAxisData)},
                           m_XAxisUnit{other.m_XAxisUnit},
                           m_ValuesData{std::make_shared<ArrayData<Dim> >(*other.m_ValuesData)},
                           m_ValuesUnit{other.m_ValuesUnit},
                           m_YAxis{other.m_YAxis}
                 {
                     // Since a series is ordered from its construction and is always ordered, it is not
                     // necessary to call the sort method here ('other' is sorted)
                 }
                 /// Assignment operator
                 template <int D>
                 DataSeries &operator=(DataSeries<D> other)
                 {
                     std::swap(m_XAxisData, other.m_XAxisData);
                     std::swap(m_XAxisUnit, other.m_XAxisUnit);
                     std::swap(m_ValuesData, other.m_ValuesData);
                     std::swap(m_ValuesUnit, other.m_ValuesUnit);
                     std::swap(m_YAxis, other.m_YAxis);
                     return *this;
                 }
             private:
                 /**
                  * Sorts data series on its x-axis data
                  */
                 void sort() noexcept
                 {
                     auto permutation = SortUtils::sortPermutation(*m_XAxisData, std::less<double>());
                     m_XAxisData = m_XAxisData->sort(permutation);
                     m_ValuesData = m_ValuesData->sort(permutation);
                 }
                 // x-axis
                 std::shared_ptr<ArrayData<1> > m_XAxisData;
                 Unit m_XAxisUnit;
                 // values
                 std::shared_ptr<ArrayData<Dim> > m_ValuesData;
                 Unit m_ValuesUnit;
                 // y-axis (optional)
                 OptionalAxis m_YAxis;
                 QReadWriteLock m_Lock;
             };
             #endif // SCIQLOP_DATASERIES_H

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

             #ifndef SCIQLOP_DATASERIESITERATOR_H
             #define SCIQLOP_DATASERIESITERATOR_H
             #include "CoreGlobal.h"
             #include "Data/SqpIterator.h"
             #include <QVector>
             #include <memory>
             /**
              * @brief The DataSeriesIteratorValue class represents the current value of a data series iterator.
              * It offers standard access methods for the data in the series (x-axis, values), but it is up to
              * each series to define its own implementation of how to retrieve this data, by implementing the
              * DataSeriesIteratorValue::Impl interface
              *
              * @sa DataSeriesIterator
              */
             class SCIQLOP_CORE_EXPORT DataSeriesIteratorValue {
             public:
                 struct Impl {
                     virtual ~Impl() noexcept = default;
                     virtual std::unique_ptr<Impl> clone() const = 0;
                     virtual int distance(const Impl &other) const = 0;
                     virtual bool equals(const Impl &other) const = 0;
                     virtual bool lowerThan(const Impl &other) const = 0;
                     virtual std::unique_ptr<Impl> advance(int offset) const = 0;
                     virtual void next(int offset) = 0;
                     virtual void prev() = 0;
                     virtual double x() const = 0;
+                    virtual std::vector<double> y() const = 0;
                     virtual double value() const = 0;
                     virtual double value(int componentIndex) const = 0;
                     virtual double minValue() const = 0;
                     virtual double maxValue() const = 0;
                     virtual QVector<double> values() const = 0;
                     virtual void swap(Impl &other) = 0;
                 };
                 explicit DataSeriesIteratorValue(std::unique_ptr<Impl> impl);
                 DataSeriesIteratorValue(const DataSeriesIteratorValue &other);
                 DataSeriesIteratorValue &operator=(DataSeriesIteratorValue other);
                 int distance(const DataSeriesIteratorValue &other) const;
                 bool equals(const DataSeriesIteratorValue &other) const;
                 bool lowerThan(const DataSeriesIteratorValue &other) const;
                 DataSeriesIteratorValue advance(int offset) const;
                 /// Advances to the next value
                 void next(int offset = 1);
                 /// Moves back to the previous value
                 void prev();
                 /// Gets x-axis data
                 double x() const;
+                /// Gets y-axis data
+                std::vector<double> y() const;
                 /// Gets value data
                 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;
                 /// Gets all values data
                 QVector<double> values() const;
                 Impl *impl();
                 friend void swap(DataSeriesIteratorValue &lhs, DataSeriesIteratorValue &rhs)
                 {
                     std::swap(lhs.m_Impl, rhs.m_Impl);
                 }
             private:
                 std::unique_ptr<Impl> m_Impl;
             };
             using DataSeriesIterator = SqpIterator<DataSeriesIteratorValue>;
             #endif // SCIQLOP_DATASERIESITERATOR_H

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

             #ifndef SCIQLOP_IDATASERIES_H
             #define SCIQLOP_IDATASERIES_H
             #include <Common/MetaTypes.h>
             #include <Data/DataSeriesIterator.h>
             #include <Data/SqpRange.h>
             #include <Data/Unit.h>
             #include <memory>
             #include <QString>
             template <int Dim>
             class ArrayData;
             /**
              * @brief The IDataSeries aims to declare a data series.
              *
              * A data series is an entity that contains at least :
              * - one dataset representing the x-axis
              * - one dataset representing the values
              *
              * Each dataset is represented by an ArrayData, and is associated with a unit.
              *
              * An ArrayData can be unidimensional or two-dimensional, depending on the implementation of the
              * IDataSeries. The x-axis dataset is always unidimensional.
              *
              * @sa ArrayData
              */
             class IDataSeries {
             public:
                 virtual ~IDataSeries() noexcept = default;
                 /// Returns the x-axis dataset
                 virtual std::shared_ptr<ArrayData<1> > xAxisData() = 0;
                 /// Returns the x-axis dataset (as const)
                 virtual const std::shared_ptr<ArrayData<1> > xAxisData() const = 0;
                 virtual Unit xAxisUnit() const = 0;
+                /// @return the y-axis unit, if axis is defined, default unit otherwise
+                virtual Unit yAxisUnit() const = 0;
                 virtual Unit valuesUnit() const = 0;
                 virtual void merge(IDataSeries *dataSeries) = 0;
                 /// Removes from data series all entries whose value on the x-axis is not between min and max
                 virtual void purge(double min, double max) = 0;
                 /// @todo Review the name and signature of this method
                 virtual std::shared_ptr<IDataSeries> subDataSeries(const SqpRange &range) = 0;
                 virtual std::unique_ptr<IDataSeries> clone() const = 0;
                 /// @return the total number of points contained in the data series
                 virtual int nbPoints() const = 0;
+                /// @return the bounds of the y-axis axis (if defined)
+                virtual std::pair<double, double> yBounds() const = 0;
                 // ///////// //
                 // Iterators //
                 // ///////// //
                 virtual DataSeriesIterator cbegin() const = 0;
                 virtual DataSeriesIterator cend() const = 0;
                 virtual DataSeriesIterator begin() = 0;
                 virtual DataSeriesIterator end() = 0;
                 /// @return the iterator to the first entry of the data series whose x-axis data is greater than
                 /// or equal to the value passed in parameter, or the end iterator if there is no matching value
                 virtual DataSeriesIterator minXAxisData(double minXAxisData) const = 0;
                 /// @return the iterator to the last entry of the data series whose x-axis data is less than or
                 /// equal to the value passed in parameter, or the end iterator if there is no matching value
                 virtual DataSeriesIterator maxXAxisData(double maxXAxisData) const = 0;
                 /// @return the iterators pointing to the range of data whose x-axis values are between min and
                 /// max passed in parameters
                 virtual std::pair<DataSeriesIterator, DataSeriesIterator>
                 xAxisRange(double minXAxisData, double maxXAxisData) const = 0;
                 /// @return two iterators pointing to the data that have respectively the min and the max value
                 /// data of a data series' range. The search is performed for a given x-axis range.
                 /// @sa xAxisRange()
                 virtual std::pair<DataSeriesIterator, DataSeriesIterator>
                 valuesBounds(double minXAxisData, double maxXAxisData) const = 0;
                 // /////// //
                 // Mutexes //
                 // /////// //
                 virtual void lockRead() = 0;
                 virtual void lockWrite() = 0;
                 virtual void unlock() = 0;
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(IDATASERIES_PTR_REGISTRY, std::shared_ptr<IDataSeries>)
             #endif // SCIQLOP_IDATASERIES_H

core/include/Data/OptionalAxis.h +8 -4

             #ifndef SCIQLOP_OPTIONALAXIS_H
             #define SCIQLOP_OPTIONALAXIS_H
+            #include <Data/ArrayDataIterator.h>
             #include "CoreGlobal.h"
             #include "Unit.h"
             #include <memory>
             template <int Dim>
             class ArrayData;
             /**
              * @brief The OptionalAxis class defines an optional data axis for a series of data.
              *
              * An optional data axis is an axis that can be defined or not for a data series. If defined, it
              * contains a unit and data (1-dim ArrayData). It is then possible to access the data or the unit.
              * In the case of an undefined axis, the axis has no data and no unit. The methods for accessing the
              * data or the unit are always callable but will return undefined values.
              *
              * @sa DataSeries
              * @sa ArrayData
              */
             class SCIQLOP_CORE_EXPORT OptionalAxis {
             public:
                 /// Ctor for an undefined axis
                 explicit OptionalAxis();
                 /// Ctor for a defined axis
                 /// @param data the axis' data
                 /// @param unit the axis' unit
                 /// @throws std::invalid_argument if no data is associated to the axis
                 explicit OptionalAxis(std::shared_ptr<ArrayData<1> > data, Unit unit);
                 /// Copy ctor
                 OptionalAxis(const OptionalAxis &other);
                 /// Assignment operator
                 OptionalAxis &operator=(OptionalAxis other);
                 /// @return the flag that indicates if the axis is defined or not
                 bool isDefined() const;
-                /// @return gets the data at the index passed in parameter, NaN if the index is outside the
-                /// bounds of the axis, or if the axis is undefined
-                double at(int index) const;
                 ///@return the min and max values of the data on the axis, NaN values if there is no data
                 std::pair<double, double> bounds() const;
                 /// @return the number of data on the axis, 0 if the axis is not defined
                 int size() const;
                 /// @return the unit of the axis, an empty unit if the axis is not defined
                 Unit unit() const;
                 bool operator==(const OptionalAxis &other);
                 bool operator!=(const OptionalAxis &other);
+                // Iterators on data
+                ArrayDataIterator begin();
+                ArrayDataIterator end();
+                ArrayDataIterator cbegin() const;
+                ArrayDataIterator cend() const;
             private:
                 bool m_Defined;                        ///< Axis is defined or not
                 std::shared_ptr<ArrayData<1> > m_Data; ///< Axis' data
                 Unit m_Unit;                           ///< Axis' unit
             };
             #endif // SCIQLOP_OPTIONALAXIS_H

core/include/Data/SpectrogramSeries.h +9 -2

             #ifndef SCIQLOP_SPECTROGRAMSERIES_H
             #define SCIQLOP_SPECTROGRAMSERIES_H
             #include "CoreGlobal.h"
             #include <Data/DataSeries.h>
             /**
              * @brief The SpectrogramSeries class is the implementation for a data series representing a
              * spectrogram.
              *
              * It defines values on a x-axis and a y-axis.
              */
             class SCIQLOP_CORE_EXPORT SpectrogramSeries : public DataSeries<2> {
             public:
                 /// Ctor
                 explicit SpectrogramSeries(std::vector<double> xAxisData, std::vector<double> yAxisData,
                                            std::vector<double> valuesData, const Unit &xAxisUnit,
-                                           const Unit &yAxisUnit, const Unit &valuesUnit);
+                                           const Unit &yAxisUnit, const Unit &valuesUnit,
+                                           double xResolution = std::numeric_limits<double>::quiet_NaN());
                 /// Ctor directly with the y-axis
                 explicit SpectrogramSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
                                            std::shared_ptr<ArrayData<2> > valuesData, const Unit &valuesUnit,
-                                           OptionalAxis yAxis);
+                                           OptionalAxis yAxis,
+                                           double xResolution = std::numeric_limits<double>::quiet_NaN());
                 /// @sa DataSeries::clone()
                 std::unique_ptr<IDataSeries> clone() const override;
                 /// @sa DataSeries::subDataSeries()
                 std::shared_ptr<IDataSeries> subDataSeries(const SqpRange &range) override;
+                inline double xResolution() const noexcept { return m_XResolution; }
+            private:
+                double m_XResolution; ///< Resolution used on x-axis to build the spectrogram
             };
             #endif // SCIQLOP_SPECTROGRAMSERIES_H

core/meson.build +1 0

             core_moc_headers = [
               'include/Data/IDataProvider.h',
               'include/DataSource/DataSourceController.h',
               'include/DataSource/DataSourceItemAction.h',
               'include/Network/NetworkController.h',
               'include/Time/TimeController.h',
               'include/Variable/Variable.h',
               'include/Variable/VariableCacheController.h',
               'include/Variable/VariableController.h',
               'include/Variable/VariableAcquisitionWorker.h',
               'include/Variable/VariableSynchronizationGroup.h',
               'include/Variable/VariableModel.h',
               'include/Visualization/VisualizationController.h'
             ]
             core_moc_files = qt5.preprocess(moc_headers : core_moc_headers)
             core_sources = [
               'src/Common/DateUtils.cpp',
               'src/Common/StringUtils.cpp',
               'src/Common/MimeTypesDef.cpp',
               'src/Data/ScalarSeries.cpp',
               'src/Data/SpectrogramSeries.cpp',
               'src/Data/DataSeriesIterator.cpp',
               'src/Data/ArrayDataIterator.cpp',
               'src/Data/VectorSeries.cpp',
               'src/Data/OptionalAxis.cpp',
+              'src/Data/DataSeriesUtils.cpp',
               'src/DataSource/DataSourceController.cpp',
               'src/DataSource/DataSourceItem.cpp',
               'src/DataSource/DataSourceItemAction.cpp',
               'src/Network/NetworkController.cpp',
               'src/Plugin/PluginManager.cpp',
               'src/Settings/SqpSettingsDefs.cpp',
               'src/Time/TimeController.cpp',
               'src/Variable/Variable.cpp',
               'src/Variable/VariableCacheController.cpp',
               'src/Variable/VariableController.cpp',
               'src/Variable/VariableAcquisitionWorker.cpp',
               'src/Variable/VariableSynchronizationGroup.cpp',
               'src/Variable/VariableModel.cpp',
               'src/Visualization/VisualizationController.cpp'
             ]
             core_inc = include_directories(['include', '../plugin/include'])
             sciqlop_core_lib = library('sciqlopcore',
                                    core_sources,
                                    core_moc_files,
                                    cpp_args : '-DCORE_LIB',
                                    include_directories : core_inc,
                                    dependencies : [qt5core, qt5network],
                                    install : true
                                    )
             sciqlop_core = declare_dependency(link_with : sciqlop_core_lib,
                                             include_directories : core_inc,
                                             dependencies : [qt5core, qt5network])
             subdir('tests')

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

             #include "Data/DataSeriesIterator.h"
             DataSeriesIteratorValue::DataSeriesIteratorValue(
                 std::unique_ptr<DataSeriesIteratorValue::Impl> impl)
                     : m_Impl{std::move(impl)}
             {
             }
             DataSeriesIteratorValue::DataSeriesIteratorValue(const DataSeriesIteratorValue &other)
                     : m_Impl{other.m_Impl->clone()}
             {
             }
             DataSeriesIteratorValue &DataSeriesIteratorValue::operator=(DataSeriesIteratorValue other)
             {
                 m_Impl->swap(*other.m_Impl);
                 return *this;
             }
             int DataSeriesIteratorValue::distance(const DataSeriesIteratorValue &other) const
             {
                 return m_Impl->distance(*other.m_Impl);
             }
             bool DataSeriesIteratorValue::equals(const DataSeriesIteratorValue &other) const
             {
                 return m_Impl->equals(*other.m_Impl);
             }
             bool DataSeriesIteratorValue::lowerThan(const DataSeriesIteratorValue &other) const
             {
                 return m_Impl->lowerThan(*other.m_Impl);
             }
             DataSeriesIteratorValue DataSeriesIteratorValue::advance(int offset) const
             {
                 return DataSeriesIteratorValue{m_Impl->advance(offset)};
             }
             void DataSeriesIteratorValue::next(int offset)
             {
                 m_Impl->next(offset);
             }
             void DataSeriesIteratorValue::prev()
             {
                 m_Impl->prev();
             }
             double DataSeriesIteratorValue::x() const
             {
                 return m_Impl->x();
             }
+            std::vector<double> DataSeriesIteratorValue::y() const
+            {
+                return m_Impl->y();
+            }
             double DataSeriesIteratorValue::value() const
             {
                 return m_Impl->value();
             }
             double DataSeriesIteratorValue::value(int componentIndex) const
             {
                 return m_Impl->value(componentIndex);
             }
             double DataSeriesIteratorValue::minValue() const
             {
                 return m_Impl->minValue();
             }
             double DataSeriesIteratorValue::maxValue() const
             {
                 return m_Impl->maxValue();
             }
             QVector<double> DataSeriesIteratorValue::values() const
             {
                 return m_Impl->values();
             }
             DataSeriesIteratorValue::Impl *DataSeriesIteratorValue::impl()
             {
                 return m_Impl.get();
             }

core/src/Data/OptionalAxis.cpp +23 -15

             #include <Data/OptionalAxis.h>
             #include "Data/ArrayData.h"
-            OptionalAxis::OptionalAxis() : m_Defined{false}, m_Data{nullptr}, m_Unit{}
+            OptionalAxis::OptionalAxis()
+                    : m_Defined{false}, m_Data{std::make_shared<ArrayData<1> >(std::vector<double>{})}, m_Unit{}
             {
             }
             OptionalAxis::OptionalAxis(std::shared_ptr<ArrayData<1> > data, Unit unit)
                     : m_Defined{true}, m_Data{data}, m_Unit{std::move(unit)}
             {
                 if (m_Data == nullptr) {
                     throw std::invalid_argument{"Data can't be null for a defined axis"};
                 }
             }
             OptionalAxis::OptionalAxis(const OptionalAxis &other)
-                    : m_Defined{other.m_Defined},
+                    : m_Defined{other.m_Defined}, m_Data{other.m_Data}, m_Unit{other.m_Unit}
-                      m_Data{other.m_Data ? std::make_shared<ArrayData<1> >(*other.m_Data) : nullptr},
-                      m_Unit{other.m_Unit}
             {
             }
             OptionalAxis &OptionalAxis::operator=(OptionalAxis other)
             {
                 std::swap(m_Defined, other.m_Defined);
                 std::swap(m_Data, other.m_Data);
                 std::swap(m_Unit, other.m_Unit);
                 return *this;
             }
             bool OptionalAxis::isDefined() const
             {
                 return m_Defined;
             }
-            double OptionalAxis::at(int index) const
-                if (m_Defined) {
-                    return (index >= 0 && index < m_Data->size()) ? m_Data->at(index)
-                                                                  : std::numeric_limits<double>::quiet_NaN();
-                else {
-                    return std::numeric_limits<double>::quiet_NaN();
             std::pair<double, double> OptionalAxis::bounds() const
             {
                 if (!m_Defined || m_Data->size() == 0) {
                     return std::make_pair(std::numeric_limits<double>::quiet_NaN(),
                                           std::numeric_limits<double>::quiet_NaN());
                 }
                 else {
                     auto minIt = std::min_element(
                         m_Data->cbegin(), m_Data->cend(), [](const auto &it1, const auto &it2) {
                             return SortUtils::minCompareWithNaN(it1.first(), it2.first());
                         });
                     // Gets the iterator on the max of all values data
                     auto maxIt = std::max_element(
                         m_Data->cbegin(), m_Data->cend(), [](const auto &it1, const auto &it2) {
                             return SortUtils::maxCompareWithNaN(it1.first(), it2.first());
                         });
                     return std::make_pair(minIt->first(), maxIt->first());
                 }
             }
             int OptionalAxis::size() const
             {
                 return m_Defined ? m_Data->size() : 0;
             }
             Unit OptionalAxis::unit() const
             {
                 return m_Defined ? m_Unit : Unit{};
             }
             bool OptionalAxis::operator==(const OptionalAxis &other)
             {
                 // Axis not defined
                 if (!m_Defined) {
                     return !other.m_Defined;
                 }
                 // Axis defined
                 return m_Unit == other.m_Unit
                        && std::equal(
                               m_Data->cbegin(), m_Data->cend(), other.m_Data->cbegin(), other.m_Data->cend(),
                               [](const auto &it1, const auto &it2) { return it1.values() == it2.values(); });
             }
             bool OptionalAxis::operator!=(const OptionalAxis &other)
             {
                 return !(*this == other);
             }
+            ArrayDataIterator OptionalAxis::begin()
+            {
+                return m_Data->begin();
+            }
+            ArrayDataIterator OptionalAxis::end()
+            {
+                return m_Data->end();
+            }
+            ArrayDataIterator OptionalAxis::cbegin() const
+            {
+                return m_Data->cbegin();
+            }
+            ArrayDataIterator OptionalAxis::cend() const
+            {
+                return m_Data->cend();
+            }

core/src/Data/SpectrogramSeries.cpp +11 -6

             #include <Data/SpectrogramSeries.h>
             SpectrogramSeries::SpectrogramSeries(std::vector<double> xAxisData, std::vector<double> yAxisData,
                                                  std::vector<double> valuesData, const Unit &xAxisUnit,
-                                                 const Unit &yAxisUnit, const Unit &valuesUnit)
+                                                 const Unit &yAxisUnit, const Unit &valuesUnit,
+                                                 double resolution)
                     : SpectrogramSeries{
-                          std::make_shared<ArrayData<1> >(std::move(xAxisData)), xAxisUnit,
+                          std::make_shared<ArrayData<1> >(std::move(xAxisData)),
-                          std::make_shared<ArrayData<2> >(std::move(valuesData), yAxisData.size()), valuesUnit,
+                          xAxisUnit,
-                          OptionalAxis{std::make_shared<ArrayData<1> >(std::move(yAxisData)), yAxisUnit}}
+                          std::make_shared<ArrayData<2> >(std::move(valuesData), yAxisData.size()),
+                          valuesUnit,
+                          OptionalAxis{std::make_shared<ArrayData<1> >(std::move(yAxisData)), yAxisUnit},
+                          resolution}
             {
             }
             SpectrogramSeries::SpectrogramSeries(std::shared_ptr<ArrayData<1> > xAxisData,
                                                  const Unit &xAxisUnit,
                                                  std::shared_ptr<ArrayData<2> > valuesData,
-                                                 const Unit &valuesUnit, OptionalAxis yAxis)
+                                                 const Unit &valuesUnit, OptionalAxis yAxis, double resolution)
                     : DataSeries{std::move(xAxisData), xAxisUnit, std::move(valuesData), valuesUnit,
-                                 std::move(yAxis)}
+                                 std::move(yAxis)},
+                      m_XResolution{resolution}
             {
             }
             std::unique_ptr<IDataSeries> SpectrogramSeries::clone() const
             {
                 return std::make_unique<SpectrogramSeries>(*this);
             }
             std::shared_ptr<IDataSeries> SpectrogramSeries::subDataSeries(const SqpRange &range)
             {
                 auto subXAxisData = std::vector<double>();
                 auto subValuesData = QVector<double>(); // Uses QVector to append easily values to it
                 this->lockRead();
                 auto bounds = xAxisRange(range.m_TStart, range.m_TEnd);
                 for (auto it = bounds.first; it != bounds.second; ++it) {
                     subXAxisData.push_back(it->x());
                     subValuesData.append(it->values());
                 }
                 auto yAxis = this->yAxis();
                 this->unlock();
                 return std::make_shared<SpectrogramSeries>(
                     std::make_shared<ArrayData<1> >(std::move(subXAxisData)), this->xAxisUnit(),
                     std::make_shared<ArrayData<2> >(subValuesData.toStdVector(), yAxis.size()),
                     this->valuesUnit(), std::move(yAxis));
             }

core/tests/Data/DataSeriesTestsUtils.cpp ~~core/tests/Data/DataSeriesUtils.cpp~~ renamed +1 -1

-            #include "DataSeriesUtils.h"
+            #include "DataSeriesTestsUtils.h"
             void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
                                const DataContainer &valuesData)
             {
                 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
                                    [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
                 QVERIFY(std::equal(
                     first, last, valuesData.cbegin(), valuesData.cend(),
                     [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
             }
             void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData, const std::vector<DataContainer> &valuesData)
             {
                 QVERIFY(std::equal(first, last, xData.cbegin(), xData.cend(),
                                    [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
                 for (auto i = 0u; i < valuesData.size(); ++i) {
                     auto componentData = valuesData.at(i);
                     QVERIFY(std::equal(
                                 first, last, componentData.cbegin(), componentData.cend(),
                                 [i](const auto &it, const auto &expectedVal) { return it.value(i) == expectedVal; }));
                 }
             }

core/tests/Data/DataSeriesTestsUtils.h ~~core/tests/Data/DataSeriesUtils.h~~ renamed +4 -4

             /**
-             * The DataSeriesUtils file contains a set of utility methods that can be used to test the operations on a DataSeries.
+             * The DataSeriesTestsUtils file contains a set of utility methods that can be used to test the operations on a DataSeries.
              *
              * Most of these methods are template methods to adapt to any series (scalars, vectors, spectrograms...)
              *
              * @sa DataSeries
              */
-            #ifndef SCIQLOP_DATASERIESUTILS_H
+            #ifndef SCIQLOP_DATASERIESTESTSUTILS_H
-            #define SCIQLOP_DATASERIESUTILS_H
+            #define SCIQLOP_DATASERIESTESTSUTILS_H
             #include <Data/DataSeriesIterator.h>
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <memory>
             #include <QtTest>
             /// Underlying data in ArrayData
             using DataContainer = std::vector<double>;
             Q_DECLARE_METATYPE(std::shared_ptr<ScalarSeries>)
             Q_DECLARE_METATYPE(std::shared_ptr<SpectrogramSeries>)
             Q_DECLARE_METATYPE(std::shared_ptr<VectorSeries>)
             /**
              * Checks that the range of a 1-dim data series contains the expected x-axis data and values data
              * @param first the iterator on the beginning of the range to check
              * @param last the iterator on the end of the range to check
              * @param xData expected x-axis data for the range
              * @param valuesData expected values data for the range
              */
             void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
                                const DataContainer &valuesData);
             /**
              * Checks that the range of a 2-dim data series contains the expected x-axis data and values data
              * @param first the iterator on the beginning of the range to check
              * @param last the iterator on the end of the range to check
              * @param xData expected x-axis data for the range
              * @param valuesData expected values data for the range
              */
             void validateRange(DataSeriesIterator first, DataSeriesIterator last, const DataContainer &xData,
                                const std::vector<DataContainer> &valuesData);
             /**
              * Sets the structure of unit tests concerning merge of two data series
              * @tparam DataSeriesType the type of data series to merge
              * @tparam ExpectedValuesType the type of values expected after merge
              * @sa testMerge_t()
              */
             template <typename DataSeriesType, typename ExpectedValuesType>
             void testMerge_struct() {
                 // Data series to merge
                 QTest::addColumn<std::shared_ptr<DataSeriesType> >("dataSeries");
                 QTest::addColumn<std::shared_ptr<DataSeriesType> >("dataSeries2");
                 // Expected values in the first data series after merge
                 QTest::addColumn<DataContainer>("expectedXAxisData");
                 QTest::addColumn<ExpectedValuesType>("expectedValuesData");
             }
             /**
              * Unit test concerning merge of two data series
              * @sa testMerge_struct()
              */
             template <typename DataSeriesType, typename ExpectedValuesType>
             void testMerge_t(){
                 // Merges series
                 QFETCH(std::shared_ptr<DataSeriesType>, dataSeries);
                 QFETCH(std::shared_ptr<DataSeriesType>, dataSeries2);
                 dataSeries->merge(dataSeries2.get());
                 // Validates results : we check that the merge is valid
                 QFETCH(DataContainer, expectedXAxisData);
                 QFETCH(ExpectedValuesType, expectedValuesData);
                 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData, expectedValuesData);
             }
             /**
              * Sets the structure of unit tests concerning merge of two data series that are of a different type
              * @tparam SourceType the type of data series with which to make the merge
              * @tparam DestType the type of data series in which to make the merge
              * @sa testMergeDifferentTypes_t()
              */
             template <typename SourceType, typename DestType>
             void testMergeDifferentTypes_struct()
             {
                 // Data series to merge
                 QTest::addColumn<std::shared_ptr<DestType> >("dest");
                 QTest::addColumn<std::shared_ptr<SourceType> >("source");
                 // Expected values in the dest data series after merge
                 QTest::addColumn<DataContainer>("expectedXAxisData");
                 QTest::addColumn<DataContainer>("expectedValuesData");
             }
             /**
              * Unit test concerning merge of two data series that are of a different type
              * @sa testMergeDifferentTypes_struct()
              */
             template <typename SourceType, typename DestType>
             void testMergeDifferentTypes_t()
             {
                 // Merges series
                 QFETCH(std::shared_ptr<SourceType>, source);
                 QFETCH(std::shared_ptr<DestType>, dest);
                 dest->merge(source.get());
                 // Validates results : we check that the merge is valid and the data series is sorted on its
                 // x-axis data
                 QFETCH(DataContainer, expectedXAxisData);
                 QFETCH(DataContainer, expectedValuesData);
                 validateRange(dest->cbegin(), dest->cend(), expectedXAxisData, expectedValuesData);
             }
             /**
              * Sets the structure of unit tests concerning getting the min x-axis data of a data series
              * @tparam T the type of data series on which to make the operation
              * @sa testMinXAxisData_t()
              */
             template <typename T>
             void testMinXAxisData_struct(){
                 // Data series to get min data
                 QTest::addColumn<std::shared_ptr<T> >("dataSeries");
                 // Min data
                 QTest::addColumn<double>("min");
                 // Expected results
                 QTest::addColumn<bool>(
                     "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
                 QTest::addColumn<double>(
                     "expectedMin"); // Expected value when method doesn't return end iterator
             }
             /**
              * Unit test concerning getting the min x-axis data of a data series
              * @sa testMinXAxisData_struct()
              */
             template <typename T>
             void testMinXAxisData_t()
             {
                 QFETCH(std::shared_ptr<T>, dataSeries);
                 QFETCH(double, min);
                 QFETCH(bool, expectedOK);
                 QFETCH(double, expectedMin);
                 auto it = dataSeries->minXAxisData(min);
                 QCOMPARE(expectedOK, it != dataSeries->cend());
                 // If the method doesn't return a end iterator, checks with expected value
                 if (expectedOK) {
                     QCOMPARE(expectedMin, it->x());
                 }
             }
             /**
              * Sets the structure of unit tests concerning getting the max x-axis data of a data series
              * @tparam T the type of data series on which to make the operation
              * @sa testMaxXAxisData_t()
              */
             template <typename T>
             void testMaxXAxisData_struct(){
                 // Data series to get max data
                 QTest::addColumn<std::shared_ptr<T> >("dataSeries");
                 // Max data
                 QTest::addColumn<double>("max");
                 // Expected results
                 QTest::addColumn<bool>(
                     "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
                 QTest::addColumn<double>(
                     "expectedMax"); // Expected value when method doesn't return end iterator
             }
             /**
              * Unit test concerning getting the max x-axis data of a data series
              * @sa testMaxXAxisData_struct()
              */
             template <typename T>
             void testMaxXAxisData_t()
             {
                 QFETCH(std::shared_ptr<T>, dataSeries);
                 QFETCH(double, max);
                 QFETCH(bool, expectedOK);
                 QFETCH(double, expectedMax);
                 auto it = dataSeries->maxXAxisData(max);
                 QCOMPARE(expectedOK, it != dataSeries->cend());
                 // If the method doesn't return a end iterator, checks with expected value
                 if (expectedOK) {
                     QCOMPARE(expectedMax, it->x());
                 }
             }
             /**
              * Sets the structure of unit tests concerning getting the purge of a data series
              * @tparam T the type of data series on which to make the operation
              * @sa testMinXAxisData_t()
              */
             template <typename T>
             void testPurge_struct()
             {
                 // Data series to purge
                 QTest::addColumn<std::shared_ptr<T> >("dataSeries");
                 QTest::addColumn<double>("min");
                 QTest::addColumn<double>("max");
                 // Expected values after purge
                 QTest::addColumn<DataContainer>("expectedXAxisData");
                 QTest::addColumn<std::vector<DataContainer> >("expectedValuesData");
             }
             /**
              * Unit test concerning getting the purge of a data series
              * @sa testPurge_struct()
              */
             template <typename T>
             void testPurge_t(){
                 QFETCH(std::shared_ptr<T>, dataSeries);
                 QFETCH(double, min);
                 QFETCH(double, max);
                 dataSeries->purge(min, max);
                 // Validates results
                 QFETCH(DataContainer, expectedXAxisData);
                 QFETCH(std::vector<DataContainer>, expectedValuesData);
                 validateRange(dataSeries->cbegin(), dataSeries->cend(), expectedXAxisData,
                               expectedValuesData);
             }
             /**
              * Sets the structure of unit tests concerning getting subdata of a data series
              * @tparam DataSeriesType the type of data series on which to make the operation
              * @tparam ExpectedValuesType the type of values expected after the operation
              * @sa testSubDataSeries_t()
              */
             template <typename DataSeriesType, typename ExpectedValuesType>
             void testSubDataSeries_struct() {
                 // Data series from which extract the subdata series
                 QTest::addColumn<std::shared_ptr<DataSeriesType> >("dataSeries");
                 // Range to extract
                 QTest::addColumn<SqpRange>("range");
                 // Expected values for the subdata series
                 QTest::addColumn<DataContainer>("expectedXAxisData");
                 QTest::addColumn<ExpectedValuesType>("expectedValuesData");
             }
             /**
              * Unit test concerning getting subdata of a data series
              * @sa testSubDataSeries_struct()
              */
             template <typename DataSeriesType, typename ExpectedValuesType>
             void testSubDataSeries_t(){
                 QFETCH(std::shared_ptr<DataSeriesType>, dataSeries);
                 QFETCH(SqpRange, range);
                 // Makes the operation
                 auto subDataSeries = std::dynamic_pointer_cast<DataSeriesType>(dataSeries->subDataSeries(range));
                 QVERIFY(subDataSeries != nullptr);
                 // Validates results
                 QFETCH(DataContainer, expectedXAxisData);
                 QFETCH(ExpectedValuesType, expectedValuesData);
                 validateRange(subDataSeries->cbegin(), subDataSeries->cend(), expectedXAxisData, expectedValuesData);
             }
             /**
              * Sets the structure of unit tests concerning getting the range of a data series
              * @tparam T the type of data series on which to make the operation
              * @sa testXAxisRange_t()
              */
             template <typename T>
             void testXAxisRange_struct(){
                 // Data series to get x-axis range
                 QTest::addColumn<std::shared_ptr<T> >("dataSeries");
                 // Min/max values
                 QTest::addColumn<double>("min");
                 QTest::addColumn<double>("max");
                 // Expected values
                 QTest::addColumn<DataContainer>("expectedXAxisData");
                 QTest::addColumn<DataContainer>("expectedValuesData");
             }
             /**
              * Unit test concerning getting the range of a data series
              * @sa testXAxisRange_struct()
              */
             template <typename T>
             void testXAxisRange_t(){
                 QFETCH(std::shared_ptr<T>, dataSeries);
                 QFETCH(double, min);
                 QFETCH(double, max);
                 QFETCH(DataContainer, expectedXAxisData);
                 QFETCH(DataContainer, expectedValuesData);
                 auto bounds = dataSeries->xAxisRange(min, max);
                 validateRange(bounds.first, bounds.second, expectedXAxisData, expectedValuesData);
             }
             /**
              * Sets the structure of unit tests concerning getting values bounds of a data series
              * @tparam T the type of data series on which to make the operation
              * @sa testValuesBounds_t()
              */
             template <typename T>
             void testValuesBounds_struct()
             {
                 // Data series to get values bounds
                 QTest::addColumn<std::shared_ptr<T> >("dataSeries");
                 // x-axis range
                 QTest::addColumn<double>("minXAxis");
                 QTest::addColumn<double>("maxXAxis");
                 // Expected results
                 QTest::addColumn<bool>(
                     "expectedOK"); // Test is expected to be ok (i.e. method doesn't return end iterators)
                 QTest::addColumn<double>("expectedMinValue");
                 QTest::addColumn<double>("expectedMaxValue");
             }
             /**
              * Unit test concerning getting values bounds of a data series
              * @sa testValuesBounds_struct()
              */
             template <typename T>
             void testValuesBounds_t()
             {
                 QFETCH(std::shared_ptr<T>, dataSeries);
                 QFETCH(double, minXAxis);
                 QFETCH(double, maxXAxis);
                 QFETCH(bool, expectedOK);
                 QFETCH(double, expectedMinValue);
                 QFETCH(double, expectedMaxValue);
                 auto minMaxIts = dataSeries->valuesBounds(minXAxis, maxXAxis);
                 auto end = dataSeries->cend();
                 // Checks iterators with expected result
                 QCOMPARE(expectedOK, minMaxIts.first != end && minMaxIts.second != end);
                 if (expectedOK) {
                     auto compare = [](const auto &v1, const auto &v2) {
                         return (std::isnan(v1) && std::isnan(v2)) || v1 == v2;
                     };
                     QVERIFY(compare(expectedMinValue, minMaxIts.first->minValue()));
                     QVERIFY(compare(expectedMaxValue, minMaxIts.second->maxValue()));
                 }
             }
-            #endif // SCIQLOP_DATASERIESUTILS_H
+            #endif // SCIQLOP_DATASERIESTESTSUTILS_H

core/tests/Data/TestOptionalAxis.cpp 0 -37

             #include <Data/ArrayData.h>
             #include <Data/OptionalAxis.h>
             #include <QObject>
             #include <QtTest>
             Q_DECLARE_METATYPE(OptionalAxis)
             class TestOptionalAxis : public QObject {
                 Q_OBJECT
             private slots:
                 /// Tests the creation of a undefined axis
                 void testNotDefinedAxisCtor();
                 /// Tests the creation of a undefined axis
                 void testDefinedAxisCtor_data();
                 void testDefinedAxisCtor();
-                /// Tests @sa OptionalAxis::at() method
-                void testAt_data();
-                void testAt();
                 /// Tests @sa OptionalAxis::size() method
                 void testSize_data();
                 void testSize();
                 /// Tests @sa OptionalAxis::unit() method
                 void testUnit_data();
                 void testUnit();
             };
             void TestOptionalAxis::testNotDefinedAxisCtor()
             {
                 OptionalAxis notDefinedAxis{};
                 QVERIFY(!notDefinedAxis.isDefined());
             }
             void TestOptionalAxis::testDefinedAxisCtor_data()
             {
                 QTest::addColumn<bool>("noData"); // If set to true, nullptr is passed as data of the axis
                 QTest::addColumn<std::vector<double> >(
                     "data"); // Values assigned to the axis when 'noData' flag is set to false
                 QTest::addColumn<Unit>("unit"); // Unit assigned to the axis
                 QTest::newRow("validData") << false << std::vector<double>{1, 2, 3} << Unit{"Hz"};
                 QTest::newRow("invalidData") << true << std::vector<double>{} << Unit{"Hz"};
             }
             void TestOptionalAxis::testDefinedAxisCtor()
             {
                 QFETCH(bool, noData);
                 QFETCH(Unit, unit);
                 // When there is no data, we expect that the constructor returns exception
                 if (noData) {
                     QVERIFY_EXCEPTION_THROWN(OptionalAxis(nullptr, unit), std::invalid_argument);
                 }
                 else {
                     QFETCH(std::vector<double>, data);
                     OptionalAxis axis{std::make_shared<ArrayData<1> >(data), unit};
                     QVERIFY(axis.isDefined());
                 }
             }
-            void TestOptionalAxis::testAt_data()
-                QTest::addColumn<OptionalAxis>("axis");    // Axis used for test case (defined or not)
-                QTest::addColumn<int>("index");            // Index to test in the axis
-                QTest::addColumn<double>("expectedValue"); // Expected axis value for the index
-                OptionalAxis definedAxis{std::make_shared<ArrayData<1> >(std::vector<double>{1, 2, 3}),
-                                         Unit{"Hz"}};
-                QTest::newRow("data1") << definedAxis << 0 << 1.;
-                QTest::newRow("data2") << definedAxis << 1 << 2.;
-                QTest::newRow("data3") << definedAxis << 2 << 3.;
-                QTest::newRow("data4 (index out of bounds)")
-                    << definedAxis << 3
-                    << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for out of bounds index
-                QTest::newRow("data5 (index out of bounds)")
-                    << definedAxis << -1
-                    << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for out of bounds index
-                QTest::newRow("data6 (axis not defined)")
-                    << OptionalAxis{} << 0
-                    << std::numeric_limits<double>::quiet_NaN(); // Expects NaN for undefined axis
-            void TestOptionalAxis::testAt()
-                QFETCH(OptionalAxis, axis);
-                QFETCH(int, index);
-                QFETCH(double, expectedValue);
-                auto value = axis.at(index);
-                QVERIFY((std::isnan(value) && std::isnan(expectedValue)) || value == expectedValue);
             void TestOptionalAxis::testSize_data()
             {
                 QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not)
                 QTest::addColumn<int>("expectedSize");  // Expected number of data in the axis
                 // Lambda that creates default defined axis (with the values passed in parameter)
                 auto axis = [](std::vector<double> values) {
                     return OptionalAxis{std::make_shared<ArrayData<1> >(std::move(values)), Unit{"Hz"}};
                 };
                 QTest::newRow("data1") << axis({}) << 0;
                 QTest::newRow("data2") << axis({1, 2, 3}) << 3;
                 QTest::newRow("data3") << axis({1, 2, 3, 4}) << 4;
                 QTest::newRow("data4 (axis not defined)") << OptionalAxis{}
                                                           << 0; // Expects 0 for undefined axis
             }
             void TestOptionalAxis::testSize()
             {
                 QFETCH(OptionalAxis, axis);
                 QFETCH(int, expectedSize);
                 QCOMPARE(axis.size(), expectedSize);
             }
             void TestOptionalAxis::testUnit_data()
             {
                 QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not)
                 QTest::addColumn<Unit>("expectedUnit"); // Expected unit for the axis
                 // Lambda that creates default defined axis (with the unit passed in parameter)
                 auto axis = [](Unit unit) {
                     return OptionalAxis{std::make_shared<ArrayData<1> >(std::vector<double>{1, 2, 3}), unit};
                 };
                 QTest::newRow("data1") << axis(Unit{"Hz"}) << Unit{"Hz"};
                 QTest::newRow("data2") << axis(Unit{"t", true}) << Unit{"t", true};
                 QTest::newRow("data3 (axis not defined)") << OptionalAxis{}
                                                           << Unit{}; // Expects default unit for undefined axis
             }
             void TestOptionalAxis::testUnit()
             {
                 QFETCH(OptionalAxis, axis);
                 QFETCH(Unit, expectedUnit);
                 QCOMPARE(axis.unit(), expectedUnit);
             }
             QTEST_MAIN(TestOptionalAxis)
             #include "TestOptionalAxis.moc"

core/tests/Data/TestScalarSeries.cpp +2 -2

             #include "Data/ScalarSeries.h"
             #include "DataSeriesBuilders.h"
-            #include "DataSeriesUtils.h"
+            #include "DataSeriesTestsUtils.h"
             #include <QObject>
             #include <QtTest>
             /**
              * @brief The TestScalarSeries class defines unit tests on scalar series.
              *
-             * Most of these unit tests use generic tests defined for DataSeries (@sa DataSeriesUtils)
+             * Most of these unit tests use generic tests defined for DataSeries (@sa DataSeriesTestsUtils)
              */
             class TestScalarSeries : public QObject {
                 Q_OBJECT
             private slots:
                 /// Tests construction of a scalar series
                 void testCtor_data();
                 void testCtor();
                 /// Tests merge of two scalar series
                 void testMerge_data();
                 void testMerge();
                 /// Tests merge of a vector series in a scalar series
                 void testMergeWithVector_data();
                 void testMergeWithVector();
                 /// Tests get min x-axis data of a scalar series
                 void testMinXAxisData_data();
                 void testMinXAxisData();
                 /// Tests get max x-axis data of a scalar series
                 void testMaxXAxisData_data();
                 void testMaxXAxisData();
                 /// Tests purge of a scalar series
                 void testPurge_data();
                 void testPurge();
                 /// Tests get x-axis range of a scalar series
                 void testXAxisRange_data();
                 void testXAxisRange();
                 /// Tests get values bounds of a scalar series
                 void testValuesBounds_data();
                 void testValuesBounds();
             };
             void TestScalarSeries::testCtor_data()
             {
                 // x-axis data
                 QTest::addColumn<DataContainer>("xAxisData");
                 // values data
                 QTest::addColumn<DataContainer>("valuesData");
                 // construction expected to be valid
                 QTest::addColumn<bool>("expectOK");
                 // expected x-axis data (when construction is valid)
                 QTest::addColumn<DataContainer>("expectedXAxisData");
                 // expected values data (when construction is valid)
                 QTest::addColumn<DataContainer>("expectedValuesData");
                 QTest::newRow("invalidData (different sizes of vectors)")
                     << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 200., 300.} << false
                     << DataContainer{} << DataContainer{};
                 QTest::newRow("sortedData") << DataContainer{1., 2., 3., 4., 5.}
                                             << DataContainer{100., 200., 300., 400., 500.} << true
                                             << DataContainer{1., 2., 3., 4., 5.}
                                             << DataContainer{100., 200., 300., 400., 500.};
                 QTest::newRow("unsortedData") << DataContainer{5., 4., 3., 2., 1.}
                                               << DataContainer{100., 200., 300., 400., 500.} << true
                                               << DataContainer{1., 2., 3., 4., 5.}
                                               << DataContainer{500., 400., 300., 200., 100.};
                 QTest::newRow("unsortedData2")
                     << DataContainer{1., 4., 3., 5., 2.} << DataContainer{100., 200., 300., 400., 500.} << true
                     << DataContainer{1., 2., 3., 4., 5.} << DataContainer{100., 500., 300., 200., 400.};
             }
             void TestScalarSeries::testCtor()
             {
                 // Creates series
                 QFETCH(DataContainer, xAxisData);
                 QFETCH(DataContainer, valuesData);
                 QFETCH(bool, expectOK);
                 if (expectOK) {
                     auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                                  Unit{}, Unit{});
                     // Validates results : we check that the data series is sorted on its x-axis data
                     QFETCH(DataContainer, expectedXAxisData);
                     QFETCH(DataContainer, expectedValuesData);
                     validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedValuesData);
                 }
                 else {
                     QVERIFY_EXCEPTION_THROWN(std::make_shared<ScalarSeries>(
                                                  std::move(xAxisData), std::move(valuesData), Unit{}, Unit{}),
                                              std::invalid_argument);
                 }
             }
             void TestScalarSeries::testMerge_data()
             {
                 testMerge_struct<ScalarSeries, DataContainer>();
                 QTest::newRow("sortedMerge") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << ScalarBuilder{}
                                                     .setX({6., 7., 8., 9., 10.})
                                                     .setValues({600., 700., 800., 900., 1000.})
                                                     .build()
                                              << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
                                              << DataContainer{100., 200., 300., 400., 500.,
 ., 700., 800., 900., 1000.};
                 QTest::newRow("unsortedMerge")
                     << ScalarBuilder{}
                            .setX({6., 7., 8., 9., 10.})
                            .setValues({600., 700., 800., 900., 1000.})
                            .build()
                     << ScalarBuilder{}
                            .setX({1., 2., 3., 4., 5.})
                            .setValues({100., 200., 300., 400., 500.})
                            .build()
                     << DataContainer{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
                     << DataContainer{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
                 QTest::newRow("unsortedMerge2 (merge not made because source is in the bounds of dest)")
                     << ScalarBuilder{}
                            .setX({1., 2., 8., 9., 10})
                            .setValues({100., 200., 800., 900., 1000.})
                            .build()
                     << ScalarBuilder{}
                            .setX({3., 4., 5., 6., 7.})
                            .setValues({300., 400., 500., 600., 700.})
                            .build()
                     << DataContainer{1., 2., 8., 9., 10.} << DataContainer{100., 200., 800., 900., 1000.};
                 QTest::newRow("unsortedMerge3")
                     << ScalarBuilder{}
                            .setX({3., 4., 5., 7., 8})
                            .setValues({300., 400., 500., 700., 800.})
                            .build()
                     << ScalarBuilder{}
                            .setX({1., 2., 3., 7., 10.})
                            .setValues({100., 200., 333., 777., 1000.})
                            .build()
                     << DataContainer{1., 2., 3., 4., 5., 7., 8., 10.}
                     << DataContainer{100., 200., 300., 400., 500., 700., 800., 1000.};
                 QTest::newRow("emptySource") << ScalarBuilder{}
                                                     .setX({3., 4., 5., 7., 8})
                                                     .setValues({300., 400., 500., 700., 800.})
                                                     .build()
                                              << ScalarBuilder{}.setX({}).setValues({}).build()
                                              << DataContainer{3., 4., 5., 7., 8.}
                                              << DataContainer{300., 400., 500., 700., 800.};
             }
             void TestScalarSeries::testMerge()
             {
                 testMerge_t<ScalarSeries, DataContainer>();
             }
             void TestScalarSeries::testMergeWithVector_data()
             {
                 testMergeDifferentTypes_struct<VectorSeries, ScalarSeries>();
                 QTest::newRow("mergeVectorInScalar") << ScalarBuilder{}
                                                             .setX({1., 2., 3., 4., 5.})
                                                             .setValues({100., 200., 300., 400., 500.})
                                                             .build()
                                                      << VectorBuilder{}
                                                             .setX({6., 7., 8., 9., 10.})
                                                             .setXValues({600., 700., 800., 900., 1000.})
                                                             .setYValues({610., 710., 810., 910., 1010.})
                                                             .setZValues({620., 720., 820., 920., 1020.})
                                                             .build()
                                                      << DataContainer{1., 2., 3., 4., 5.}
                                                      << DataContainer{100., 200., 300., 400., 500.};
             }
             void TestScalarSeries::testMergeWithVector()
             {
                 testMergeDifferentTypes_t<VectorSeries, ScalarSeries>();
             }
             void TestScalarSeries::testMinXAxisData_data()
             {
                 testMinXAxisData_struct<ScalarSeries>();
                 QTest::newRow("minData1") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 0. << true << 1.;
                 QTest::newRow("minData2") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 1. << true << 1.;
                 QTest::newRow("minData3") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 1.1 << true << 2.;
                 QTest::newRow("minData4") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 5. << true << 5.;
                 QTest::newRow("minData5") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 5.1 << false << std::numeric_limits<double>::quiet_NaN();
                 QTest::newRow("minData6") << ScalarBuilder{}.setX({}).setValues({}).build() << 1.1 << false
                                           << std::numeric_limits<double>::quiet_NaN();
             }
             void TestScalarSeries::testMinXAxisData()
             {
                 testMinXAxisData_t<ScalarSeries>();
             }
             void TestScalarSeries::testMaxXAxisData_data()
             {
                 testMaxXAxisData_struct<ScalarSeries>();
                 QTest::newRow("maxData1") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 6. << true << 5.;
                 QTest::newRow("maxData2") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 5. << true << 5.;
                 QTest::newRow("maxData3") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 4.9 << true << 4.;
                 QTest::newRow("maxData4") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 1.1 << true << 1.;
                 QTest::newRow("maxData5") << ScalarBuilder{}
                                                  .setX({1., 2., 3., 4., 5.})
                                                  .setValues({100., 200., 300., 400., 500.})
                                                  .build()
                                           << 1. << true << 1.;
                 QTest::newRow("maxData6") << ScalarBuilder{}.setX({}).setValues({}).build() << 1.1 << false
                                           << std::numeric_limits<double>::quiet_NaN();
             }
             void TestScalarSeries::testMaxXAxisData()
             {
                 testMaxXAxisData_t<ScalarSeries>();
             }
             void TestScalarSeries::testPurge_data()
             {
                 testPurge_struct<ScalarSeries>();
                 QTest::newRow("purgeScalar") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 2. << 4. << DataContainer{2., 3., 4.}
                                              << std::vector<DataContainer>{{200., 300., 400.}};
                 QTest::newRow("purgeScalar1 (min/max swap)") << ScalarBuilder{}
                                                                     .setX({1., 2., 3., 4., 5.})
                                                                     .setValues({100., 200., 300., 400., 500.})
                                                                     .build()
                                                              << 4. << 2. << DataContainer{2., 3., 4.}
                                                              << std::vector<DataContainer>{{200., 300., 400.}};
                 QTest::newRow("purgeScalar2") << ScalarBuilder{}
                                                      .setX({1., 2., 3., 4., 5.})
                                                      .setValues({100., 200., 300., 400., 500.})
                                                      .build()
                                               << 0. << 2.5 << DataContainer{1., 2.}
                                               << std::vector<DataContainer>{{100., 200.}};
                 QTest::newRow("purgeScalar3") << ScalarBuilder{}
                                                      .setX({1., 2., 3., 4., 5.})
                                                      .setValues({100., 200., 300., 400., 500.})
                                                      .build()
                                               << 3.5 << 7. << DataContainer{4., 5.}
                                               << std::vector<DataContainer>{{400., 500.}};
                 QTest::newRow("purgeScalar4") << ScalarBuilder{}
                                                      .setX({1., 2., 3., 4., 5.})
                                                      .setValues({100., 200., 300., 400., 500.})
                                                      .build()
                                               << 0. << 7. << DataContainer{1., 2., 3., 4., 5.}
                                               << std::vector<DataContainer>{{100., 200., 300., 400., 500.}};
                 QTest::newRow("purgeScalar5") << ScalarBuilder{}
                                                      .setX({1., 2., 3., 4., 5.})
                                                      .setValues({100., 200., 300., 400., 500.})
                                                      .build()
                                               << 5.5 << 7. << DataContainer{} << std::vector<DataContainer>{{}};
             }
             void TestScalarSeries::testPurge()
             {
                 testPurge_t<ScalarSeries>();
             }
             void TestScalarSeries::testXAxisRange_data()
             {
                 testXAxisRange_struct<ScalarSeries>();
                 QTest::newRow("xAxisRange") << ScalarBuilder{}
                                                    .setX({1., 2., 3., 4., 5.})
                                                    .setValues({100., 200., 300., 400., 500.})
                                                    .build()
                                             << -1. << 3.2 << DataContainer{1., 2., 3.}
                                             << DataContainer{100., 200., 300.};
                 QTest::newRow("xAxisRange1 (min/max swap)") << ScalarBuilder{}
                                                                    .setX({1., 2., 3., 4., 5.})
                                                                    .setValues({100., 200., 300., 400., 500.})
                                                                    .build()
                                                             << 3.2 << -1. << DataContainer{1., 2., 3.}
                                                             << DataContainer{100., 200., 300.};
                 QTest::newRow("xAxisRange2") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 1. << 4. << DataContainer{1., 2., 3., 4.}
                                              << DataContainer{100., 200., 300., 400.};
                 QTest::newRow("xAxisRange3") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 1. << 3.9 << DataContainer{1., 2., 3.}
                                              << DataContainer{100., 200., 300.};
                 QTest::newRow("xAxisRange4") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 0. << 0.9 << DataContainer{} << DataContainer{};
                 QTest::newRow("xAxisRange5") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 0. << 1. << DataContainer{1.} << DataContainer{100.};
                 QTest::newRow("xAxisRange6") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 2.1 << 6. << DataContainer{3., 4., 5.}
                                              << DataContainer{300., 400., 500.};
                 QTest::newRow("xAxisRange7") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 6. << 9. << DataContainer{} << DataContainer{};
                 QTest::newRow("xAxisRange8") << ScalarBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setValues({100., 200., 300., 400., 500.})
                                                     .build()
                                              << 5. << 9. << DataContainer{5.} << DataContainer{500.};
             }
             void TestScalarSeries::testXAxisRange()
             {
                 testXAxisRange_t<ScalarSeries>();
             }
             void TestScalarSeries::testValuesBounds_data()
             {
                 testValuesBounds_struct<ScalarSeries>();
                 auto nan = std::numeric_limits<double>::quiet_NaN();
                 QTest::newRow("scalarBounds1") << ScalarBuilder{}
                                                       .setX({1., 2., 3., 4., 5.})
                                                       .setValues({100., 200., 300., 400., 500.})
                                                       .build()
                                                << 0. << 6. << true << 100. << 500.;
                 QTest::newRow("scalarBounds2") << ScalarBuilder{}
                                                       .setX({1., 2., 3., 4., 5.})
                                                       .setValues({100., 200., 300., 400., 500.})
                                                       .build()
                                                << 2. << 4. << true << 200. << 400.;
                 QTest::newRow("scalarBounds3") << ScalarBuilder{}
                                                       .setX({1., 2., 3., 4., 5.})
                                                       .setValues({100., 200., 300., 400., 500.})
                                                       .build()
                                                << 0. << 0.5 << false << nan << nan;
                 QTest::newRow("scalarBounds4") << ScalarBuilder{}
                                                       .setX({1., 2., 3., 4., 5.})
                                                       .setValues({100., 200., 300., 400., 500.})
                                                       .build()
                                                << 5.1 << 6. << false << nan << nan;
                 QTest::newRow("scalarBounds5") << ScalarBuilder{}.setX({1.}).setValues({100.}).build() << 0.
                                                << 2. << true << 100. << 100.;
                 QTest::newRow("scalarBounds6") << ScalarBuilder{}.setX({}).setValues({}).build() << 0. << 2.
                                                << false << nan << nan;
                 // Tests with NaN values: NaN values are not included in min/max search
                 QTest::newRow("scalarBounds7") << ScalarBuilder{}
                                                       .setX({1., 2., 3., 4., 5.})
                                                       .setValues({nan, 200., 300., 400., nan})
                                                       .build()
                                                << 0. << 6. << true << 200. << 400.;
                 QTest::newRow("scalarBounds8")
                     << ScalarBuilder{}.setX({1., 2., 3., 4., 5.}).setValues({nan, nan, nan, nan, nan}).build()
                     << 0. << 6. << true << nan << nan;
             }
             void TestScalarSeries::testValuesBounds()
             {
                 testValuesBounds_t<ScalarSeries>();
             }
             QTEST_MAIN(TestScalarSeries)
             #include "TestScalarSeries.moc"

core/tests/Data/TestSpectrogramSeries.cpp +2 -2

             #include "Data/SpectrogramSeries.h"
             #include "DataSeriesBuilders.h"
-            #include "DataSeriesUtils.h"
+            #include "DataSeriesTestsUtils.h"
             #include <QObject>
             #include <QtTest>
             namespace {
             // Aliases used to facilitate reading of test inputs
             using X = DataContainer;
             using Y = DataContainer;
             using Values = DataContainer;
             using Components = std::vector<DataContainer>;
             } // namespace
             /**
              * @brief The TestSpectrogramSeries class defines unit tests on spectrogram series.
              *
-             * Most of these unit tests use generic tests defined for DataSeries (@sa DataSeriesUtils)
+             * Most of these unit tests use generic tests defined for DataSeries (@sa DataSeriesTestsUtils)
              */
             class TestSpectrogramSeries : public QObject {
                 Q_OBJECT
             private slots:
                 /// Tests construction of a spectrogram series
                 void testCtor_data();
                 void testCtor();
                 /// Tests merge of two spectrogram series
                 void testMerge_data();
                 void testMerge();
                 /// Tests get subdata of a spectrogram series
                 void testSubDataSeries_data();
                 void testSubDataSeries();
             };
             void TestSpectrogramSeries::testCtor_data()
             {
                 // x-axis data
                 QTest::addColumn<X>("xAxisData");
                 // y-axis data
                 QTest::addColumn<Y>("yAxisData");
                 // values data
                 QTest::addColumn<Values>("valuesData");
                 // construction expected to be valid
                 QTest::addColumn<bool>("expectOK");
                 // expected x-axis data (when construction is valid)
                 QTest::addColumn<X>("expectedXAxisData");
                 // expected components data (when construction is valid)
                 QTest::addColumn<Components>("expectedComponentsData");
                 QTest::newRow(
                     "invalidData (number of values by component aren't equal to the number of x-axis data)")
                     << X{1., 2., 3., 4., 5.} << Y{1., 2., 3.} << Values{1., 2., 3.} << false << X{}
                     << Components{};
                 QTest::newRow("invalidData (number of components aren't equal to the number of y-axis data)")
                     << X{1., 2., 3., 4., 5.} << Y{1., 2.} // 2 y-axis data
                     << Values{1., 2., 3., 4., 5.}         // 1 component
                     << false << X{} << Components{};
                 QTest::newRow("sortedData") << X{1., 2., 3., 4., 5.} << Y{1., 2.}              // 2 y-axis data
                                             << Values{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.} // 2 components
                                             << true << X{1., 2., 3., 4., 5.}
                                             << Components{{1., 3., 5., 7., 9.}, {2., 4., 6., 8., 10.}};
                 QTest::newRow("unsortedData") << X{5., 4., 3., 2., 1.} << Y{1., 2.}
                                               << Values{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.} << true
                                               << X{1., 2., 3., 4., 5.}
                                               << Components{{9., 7., 5., 3., 1.}, {10., 8., 6., 4., 2.}};
             }
             void TestSpectrogramSeries::testCtor()
             {
                 // Creates series
                 QFETCH(X, xAxisData);
                 QFETCH(Y, yAxisData);
                 QFETCH(Values, valuesData);
                 QFETCH(bool, expectOK);
                 if (expectOK) {
                     auto series = SpectrogramBuilder{}
                                       .setX(std::move(xAxisData))
                                       .setY(std::move(yAxisData))
                                       .setValues(std::move(valuesData))
                                       .build();
                     // Validates results
                     QFETCH(X, expectedXAxisData);
                     QFETCH(Components, expectedComponentsData);
                     validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedComponentsData);
                 }
                 else {
                     QVERIFY_EXCEPTION_THROWN(SpectrogramBuilder{}
                                                  .setX(std::move(xAxisData))
                                                  .setY(std::move(yAxisData))
                                                  .setValues(std::move(valuesData))
                                                  .build(),
                                              std::invalid_argument);
                 }
             }
             void TestSpectrogramSeries::testMerge_data()
             {
                 testMerge_struct<SpectrogramSeries, Components>();
                 QTest::newRow("sortedMerge") << SpectrogramBuilder{}
                                                     .setX({1., 2., 3.})
                                                     .setY({1., 2.})
                                                     .setValues({10., 11., 20., 21., 30., 31})
                                                     .build()
                                              << SpectrogramBuilder{}
                                                     .setX({4., 5., 6.})
                                                     .setY({1., 2.})
                                                     .setValues({40., 41., 50., 51., 60., 61})
                                                     .build()
                                              << DataContainer{1., 2., 3., 4., 5., 6.}
                                              << Components{{10., 20., 30., 40., 50., 60.},
                                                            {11., 21., 31., 41., 51., 61}};
                 QTest::newRow(
                     "unsortedMerge (merge not made because the two data series have different y-axes)")
                     << SpectrogramBuilder{}
                            .setX({4., 5., 6.})
                            .setY({1., 2.})
                            .setValues({40., 41., 50., 51., 60., 61})
                            .build()
                     << SpectrogramBuilder{}
                            .setX({1., 2., 3.})
                            .setY({3., 4.})
                            .setValues({10., 11., 20., 21., 30., 31})
                            .build()
                     << DataContainer{4., 5., 6.} << Components{{40., 50., 60.}, {41., 51., 61}};
                 QTest::newRow(
                     "unsortedMerge (unsortedMerge (merge is made because the two data series have the same "
                     "y-axis)")
                     << SpectrogramBuilder{}
                            .setX({4., 5., 6.})
                            .setY({1., 2.})
                            .setValues({40., 41., 50., 51., 60., 61})
                            .build()
                     << SpectrogramBuilder{}
                            .setX({1., 2., 3.})
                            .setY({1., 2.})
                            .setValues({10., 11., 20., 21., 30., 31})
                            .build()
                     << DataContainer{1., 2., 3., 4., 5., 6.}
                     << Components{{10., 20., 30., 40., 50., 60.}, {11., 21., 31., 41., 51., 61}};
             }
             void TestSpectrogramSeries::testMerge()
             {
                 testMerge_t<SpectrogramSeries, Components>();
             }
             void TestSpectrogramSeries::testSubDataSeries_data()
             {
                 testSubDataSeries_struct<SpectrogramSeries, Components>();
                 QTest::newRow("subDataSeries (the range includes all data)")
                     << SpectrogramBuilder{}
                            .setX({1., 2., 3.})
                            .setY({1., 2.})
                            .setValues({10., 11., 20., 21., 30., 31})
                            .build()
                     << SqpRange{0., 5.} << DataContainer{1., 2., 3.}
                     << Components{{10., 20., 30.}, {11., 21., 31.}};
                 QTest::newRow("subDataSeries (the range includes no data)")
                     << SpectrogramBuilder{}
                            .setX({1., 2., 3.})
                            .setY({1., 2.})
                            .setValues({10., 11., 20., 21., 30., 31})
                            .build()
                     << SqpRange{4., 5.} << DataContainer{} << Components{{}, {}};
                 QTest::newRow("subDataSeries (the range includes some data)")
                     << SpectrogramBuilder{}
                            .setX({1., 2., 3.})
                            .setY({1., 2.})
                            .setValues({10., 11., 20., 21., 30., 31})
                            .build()
                     << SqpRange{1.1, 3} << DataContainer{2., 3.} << Components{{20., 30.}, {21., 31.}};
             }
             void TestSpectrogramSeries::testSubDataSeries()
             {
                 testSubDataSeries_t<SpectrogramSeries, Components>();
             }
             QTEST_MAIN(TestSpectrogramSeries)
             #include "TestSpectrogramSeries.moc"

core/tests/Data/TestVectorSeries.cpp +2 -2

             #include "Data/VectorSeries.h"
             #include "DataSeriesBuilders.h"
-            #include "DataSeriesUtils.h"
+            #include "DataSeriesTestsUtils.h"
             #include <QObject>
             #include <QtTest>
             /**
              * @brief The TestVectorSeries class defines unit tests on vector series.
              *
-             * Most of these unit tests use generic tests defined for DataSeries (@sa DataSeriesUtils)
+             * Most of these unit tests use generic tests defined for DataSeries (@sa DataSeriesTestsUtils)
              */
             class TestVectorSeries : public QObject {
                 Q_OBJECT
             private slots:
                 /// Tests purge of a vector series
                 void testPurge_data();
                 void testPurge();
                 /// Tests get values bounds of a vector series
                 void testValuesBounds_data();
                 void testValuesBounds();
             };
             void TestVectorSeries::testPurge_data()
             {
                 testPurge_struct<VectorSeries>();
                 QTest::newRow("purgeVector") << VectorBuilder{}
                                                     .setX({1., 2., 3., 4., 5.})
                                                     .setXValues({6., 7., 8., 9., 10.})
                                                     .setYValues({11., 12., 13., 14., 15.})
                                                     .setZValues({16., 17., 18., 19., 20.})
                                                     .build()
                                              << 2. << 4. << DataContainer{2., 3., 4.}
                                              << std::vector<DataContainer>{
                                                     {7., 8., 9.}, {12., 13., 14.}, {17., 18., 19.}};
             }
             void TestVectorSeries::testPurge()
             {
                 testPurge_t<VectorSeries>();
             }
             void TestVectorSeries::testValuesBounds_data()
             {
                 testValuesBounds_struct<VectorSeries>();
                 auto nan = std::numeric_limits<double>::quiet_NaN();
                 QTest::newRow("vectorBounds1") << VectorBuilder{}
                                                       .setX({1., 2., 3., 4., 5.})
                                                       .setXValues({10., 15., 20., 13., 12.})
                                                       .setYValues({35., 24., 10., 9., 0.3})
                                                       .setZValues({13., 14., 12., 9., 24.})
                                                       .build()
                                                << 0. << 6. << true << 0.3 << 35.; // min/max in same component
                 QTest::newRow("vectorBounds2") << VectorBuilder{}
                                                       .setX({1., 2., 3., 4., 5.})
                                                       .setXValues({2.3, 15., 20., 13., 12.})
                                                       .setYValues({35., 24., 10., 9., 4.})
                                                       .setZValues({13., 14., 12., 9., 24.})
                                                       .build()
                                                << 0. << 6. << true << 2.3 << 35.; // min/max in same entry
                 QTest::newRow("vectorBounds3") << VectorBuilder{}
                                                       .setX({1., 2., 3., 4., 5.})
                                                       .setXValues({2.3, 15., 20., 13., 12.})
                                                       .setYValues({35., 24., 10., 9., 4.})
                                                       .setZValues({13., 14., 12., 9., 24.})
                                                       .build()
                                                << 2. << 3. << true << 10. << 24.;
                 // Tests with NaN values: NaN values are not included in min/max search
                 QTest::newRow("vectorBounds4") << VectorBuilder{}
                                                       .setX({1., 2.})
                                                       .setXValues({nan, nan})
                                                       .setYValues({nan, nan})
                                                       .setZValues({nan, nan})
                                                       .build()
                                                << 0. << 6. << true << nan << nan;
             }
             void TestVectorSeries::testValuesBounds()
             {
                 testValuesBounds_t<VectorSeries>();
             }
             QTEST_MAIN(TestVectorSeries)
             #include "TestVectorSeries.moc"

core/tests/meson.build +3 -2

             tests = [
               [['Common/TestStringUtils.cpp'],'test_string_utils','StringUtils test'],
               [['Data/TestScalarSeries.cpp'],'test_scalar','ScalarSeries test'],
               [['Data/TestSpectrogramSeries.cpp'],'test_spectrogram','SpectrogramSeries test'],
               [['Data/TestVectorSeries.cpp'],'test_vector','VectorSeries test'],
               [['Data/TestOneDimArrayData.cpp'],'test_1d','One Dim Array test'],
               [['Data/TestOptionalAxis.cpp'],'test_optional_axis','OptionalAxis test'],
               [['Data/TestTwoDimArrayData.cpp'],'test_2d','Two Dim Array test'],
+              [['Data/TestDataSeriesUtils.cpp'],'test_dataseries_util','Data series utils test'],
               [['DataSource/TestDataSourceController.cpp'],'test_data_source','DataSourceController test'],
               [['Variable/TestVariableCacheController.cpp'],'test_variable_cache','VariableCacheController test'],
               [['Variable/TestVariable.cpp'],'test_variable','Variable test'],
               [['Variable/TestVariableSync.cpp'],'test_variable_sync','Variable synchronization test']
             ]
             amdatest_sources = [
               'Data/DataSeriesBuilders.h',
               'Data/DataSeriesBuilders.cpp',
-              'Data/DataSeriesUtils.h',
+              'Data/DataSeriesTestsUtils.h',
-              'Data/DataSeriesUtils.cpp'
+              'Data/DataSeriesTestsUtils.cpp'
             ]
             foreach unit_test : tests
               test_moc_files = qt5.preprocess(moc_sources : unit_test[0])
               test_exe = executable(unit_test[1],unit_test[0] , test_moc_files,
                                       dependencies : [sciqlop_core, qt5test],
             						  sources : [amdatest_sources])
               test(unit_test[2], test_exe, args: ['-teamcity', '-o', '@0@.teamcity.txt'.format(unit_test[1])])
             endforeach

gui/src/Visualization/AxisRenderingUtils.cpp +3 -2

             #include "Visualization/AxisRenderingUtils.h"
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <Visualization/qcustomplot.h>
             Q_LOGGING_CATEGORY(LOG_AxisRenderingUtils, "AxisRenderingUtils")
             namespace {
             const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
             /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
             /// non-time data
             QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis, QCPAxis::ScaleType scaleType)
             {
                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
                     dateTicker->setDateTimeSpec(Qt::UTC);
                     return dateTicker;
                 }
                 else if (scaleType == QCPAxis::stLogarithmic) {
                     return QSharedPointer<QCPAxisTickerLog>::create();
                 }
                 else {
                     // default ticker
                     return QSharedPointer<QCPAxisTicker>::create();
                 }
             }
             /**
              * Sets properties of the axis passed as parameter
              * @param axis the axis to set
              * @param unit the unit to set for the axis
              * @param scaleType the scale type to set for the axis
              */
             void setAxisProperties(QCPAxis &axis, const Unit &unit,
                                    QCPAxis::ScaleType scaleType = QCPAxis::stLinear)
             {
                 // label (unit name)
                 axis.setLabel(unit.m_Name);
                 // scale type
                 axis.setScaleType(scaleType);
                 if (scaleType == QCPAxis::stLogarithmic) {
                     // Scientific notation
                     axis.setNumberPrecision(0);
                     axis.setNumberFormat("eb");
                 }
                 // ticker (depending on the type of unit)
                 axis.setTicker(axisTicker(unit.m_TimeUnit, scaleType));
             }
             /**
              * Delegate used to set axes properties
              */
             template <typename T, typename Enabled = void>
             struct AxisSetter {
                 static void setProperties(T &, QCustomPlot &, QCPColorScale &)
                 {
                     // Default implementation does nothing
                     qCCritical(LOG_AxisRenderingUtils()) << "Can't set axis properties: unmanaged type of data";
                 }
             };
             /**
              * Specialization of AxisSetter for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                            or std::is_base_of<VectorSeries, T>::value> > {
                 static void setProperties(T &dataSeries, QCustomPlot &plot, QCPColorScale &)
                 {
                     dataSeries.lockRead();
                     auto xAxisUnit = dataSeries.xAxisUnit();
                     auto valuesUnit = dataSeries.valuesUnit();
                     dataSeries.unlock();
                     setAxisProperties(*plot.xAxis, xAxisUnit);
                     setAxisProperties(*plot.yAxis, valuesUnit);
                 }
             };
             /**
              * Specialization of AxisSetter for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
                 static void setProperties(T &dataSeries, QCustomPlot &plot, QCPColorScale &colorScale)
                 {
                     dataSeries.lockRead();
                     auto xAxisUnit = dataSeries.xAxisUnit();
-                    /// @todo ALX: use iterators here
+                    auto yAxisUnit = dataSeries.yAxisUnit();
-                    auto yAxisUnit = dataSeries.yAxis().unit();
                     auto valuesUnit = dataSeries.valuesUnit();
                     dataSeries.unlock();
                     setAxisProperties(*plot.xAxis, xAxisUnit);
                     setAxisProperties(*plot.yAxis, yAxisUnit, QCPAxis::stLogarithmic);
                     // Displays color scale in plot
                     plot.plotLayout()->insertRow(0);
                     plot.plotLayout()->addElement(0, 0, &colorScale);
                     colorScale.setType(QCPAxis::atTop);
                     colorScale.setMinimumMargins(QMargins{0, 0, 0, 0});
                     // Aligns color scale with axes
                     auto marginGroups = plot.axisRect()->marginGroups();
                     for (auto it = marginGroups.begin(), end = marginGroups.end(); it != end; ++it) {
                         colorScale.setMarginGroup(it.key(), it.value());
                     }
                     // Set color scale properties
                     setAxisProperties(*colorScale.axis(), valuesUnit, QCPAxis::stLogarithmic);
+                    /// @todo ALX: temp data range, remove it when widget to set data range is implemented
+                    colorScale.setDataRange(QCPRange{8.32e2, 1.77e7});
                 }
             };
             /**
              * Default implementation of IAxisHelper, which takes data series to set axes properties
              * @tparam T the data series' type
              */
             template <typename T>
             struct AxisHelper : public IAxisHelper {
                 explicit AxisHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
                 void setProperties(QCustomPlot &plot, QCPColorScale &colorScale) override
                 {
                     AxisSetter<T>::setProperties(m_DataSeries, plot, colorScale);
                 }
                 T &m_DataSeries;
             };
             } // namespace
             QString formatValue(double value, const QCPAxis &axis)
             {
                 // If the axis is a time axis, formats the value as a date
                 if (auto axisTicker = qSharedPointerDynamicCast<QCPAxisTickerDateTime>(axis.ticker())) {
                     return DateUtils::dateTime(value, axisTicker->dateTimeSpec()).toString(DATETIME_FORMAT);
                 }
                 else {
                     return QString::number(value);
                 }
             }
             std::unique_ptr<IAxisHelper>
             IAxisHelperFactory::create(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
                     return std::make_unique<AxisHelper<ScalarSeries> >(*scalarSeries);
                 }
                 else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
                     return std::make_unique<AxisHelper<SpectrogramSeries> >(*spectrogramSeries);
                 }
                 else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
                     return std::make_unique<AxisHelper<VectorSeries> >(*vectorSeries);
                 }
                 else {
                     return std::make_unique<AxisHelper<IDataSeries> >(*dataSeries);
                 }
             }

gui/src/Visualization/VisualizationGraphHelper.cpp +28 -29

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
+            #include <Data/DataSeriesUtils.h>
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <Variable/Variable.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             namespace {
             class SqpDataContainer : public QCPGraphDataContainer {
             public:
                 void appendGraphData(const QCPGraphData &data) { mData.append(data); }
             };
             /**
              * Struct used to create plottables, depending on the type of the data series from which to create
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't create plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesCreator {
                 static PlottablesMap createPlottables(T &, QCustomPlot &)
                 {
                     qCCritical(LOG_DataSeries())
                         << QObject::tr("Can't create plottables: unmanaged data series type");
                     return {};
                 }
             };
             /**
              * Specialization of PlottablesCreator for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesCreator<T,
                                      typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                                or std::is_base_of<VectorSeries, T>::value> > {
                 static PlottablesMap createPlottables(T &dataSeries, QCustomPlot &plot)
                 {
                     PlottablesMap result{};
                     // Gets the number of components of the data series
                     dataSeries.lockRead();
                     auto componentCount = dataSeries.valuesData()->componentCount();
                     dataSeries.unlock();
                     // For each component of the data series, creates a QCPGraph to add to the plot
                     for (auto i = 0; i < componentCount; ++i) {
                         auto graph = plot.addGraph();
                         result.insert({i, graph});
                     }
                     plot.replot();
                     return result;
                 }
             };
             /**
              * Specialization of PlottablesCreator for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesCreator<T,
                                      typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
                 static PlottablesMap createPlottables(T &dataSeries, QCustomPlot &plot)
                 {
                     PlottablesMap result{};
                     result.insert({0, new QCPColorMap{plot.xAxis, plot.yAxis}});
                     plot.replot();
                     return result;
                 }
             };
             /**
              * Struct used to update plottables, depending on the type of the data series from which to update
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't update plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesUpdater {
                 static void setPlotYAxisRange(T &, const SqpRange &, QCustomPlot &)
                 {
                     qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't set plot y-axis range: unmanaged data series type");
                 }
                 static void updatePlottables(T &, PlottablesMap &, const SqpRange &, bool)
                 {
                     qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't update plottables: unmanaged data series type");
                 }
             };
             /**
              * Specialization of PlottablesUpdater for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesUpdater<T,
                                      typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                                or std::is_base_of<VectorSeries, T>::value> > {
                 static void setPlotYAxisRange(T &dataSeries, const SqpRange &xAxisRange, QCustomPlot &plot)
                 {
                     auto minValue = 0., maxValue = 0.;
                     dataSeries.lockRead();
                     auto valuesBounds = dataSeries.valuesBounds(xAxisRange.m_TStart, xAxisRange.m_TEnd);
                     auto end = dataSeries.cend();
                     if (valuesBounds.first != end && valuesBounds.second != end) {
                         auto rangeValue = [](const auto &value) { return std::isnan(value) ? 0. : value; };
                         minValue = rangeValue(valuesBounds.first->minValue());
                         maxValue = rangeValue(valuesBounds.second->maxValue());
                     }
                     dataSeries.unlock();
                     plot.yAxis->setRange(QCPRange{minValue, maxValue});
                 }
                 static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const SqpRange &range,
                                              bool rescaleAxes)
                 {
                     // For each plottable to update, resets its data
                     std::map<int, QSharedPointer<SqpDataContainer> > dataContainers{};
                     for (const auto &plottable : plottables) {
                         if (auto graph = dynamic_cast<QCPGraph *>(plottable.second)) {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             graph->setData(dataContainer);
                             dataContainers.insert({plottable.first, dataContainer});
                         }
                     }
                     dataSeries.lockRead();
                     // - 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.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;
                             dataContainer.second->appendGraphData(
                                 QCPGraphData(it->x(), it->value(componentIndex)));
                         }
                     }
                     dataSeries.unlock();
                     if (!plottables.empty()) {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes) {
                             plot->rescaleAxes();
                         }
                         plot->replot();
                     }
                 }
             };
             /**
              * Specialization of PlottablesUpdater for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesUpdater<T,
                                      typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
                 static void setPlotYAxisRange(T &dataSeries, const SqpRange &xAxisRange, QCustomPlot &plot)
                 {
                     double min, max;
-                    /// @todo ALX: use iterators here
+                    std::tie(min, max) = dataSeries.yBounds();
-                    std::tie(min, max) = dataSeries.yAxis().bounds();
                     if (!std::isnan(min) && !std::isnan(max)) {
                         plot.yAxis->setRange(QCPRange{min, max});
                     }
                 }
                 static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const SqpRange &range,
                                              bool rescaleAxes)
                 {
                     if (plottables.empty()) {
                         qCDebug(LOG_VisualizationGraphHelper())
                             << QObject::tr("Can't update spectrogram: no colormap has been associated");
                         return;
                     }
                     // Gets the colormap to update (normally there is only one colormap)
                     Q_ASSERT(plottables.size() == 1);
                     auto colormap = dynamic_cast<QCPColorMap *>(plottables.at(0));
                     Q_ASSERT(colormap != nullptr);
                     dataSeries.lockRead();
+                    // Processing spectrogram data for display in QCustomPlot
                     auto its = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);
-                    /// @todo ALX: use iterators here
-                    auto yAxis = dataSeries.yAxis();
-                    // Gets properties of x-axis and y-axis to set size and range of the colormap
-                    auto nbX = std::distance(its.first, its.second);
-                    auto xMin = nbX != 0 ? its.first->x() : 0.;
-                    auto xMax = nbX != 0 ? (its.second - 1)->x() : 0.;
-                    auto nbY = yAxis.size();
-                    auto yMin = 0., yMax = 0.;
-                    if (nbY != 0) {
-                        std::tie(yMin, yMax) = yAxis.bounds();
-                    colormap->data()->setSize(nbX, nbY);
+                    // Computes logarithmic y-axis resolution for the spectrogram
-                    colormap->data()->setRange(QCPRange{xMin, xMax}, QCPRange{yMin, yMax});
+                    auto yData = its.first->y();
+                    auto yResolution = DataSeriesUtils::resolution(yData.begin(), yData.end(), true);
+                    // Generates mesh for colormap
+                    auto mesh = DataSeriesUtils::regularMesh(
+                        its.first, its.second, DataSeriesUtils::Resolution{dataSeries.xResolution()},
+                        yResolution);
+                    dataSeries.unlock();
-                    // Sets values
+                    colormap->data()->setSize(mesh.m_NbX, mesh.m_NbY);
-                    auto xIndex = 0;
+                    if (!mesh.isEmpty()) {
-                    for (auto it = its.first; it != its.second; ++it, ++xIndex) {
+                        colormap->data()->setRange(
-                        for (auto yIndex = 0; yIndex < nbY; ++yIndex) {
+                            QCPRange{mesh.m_XMin, mesh.xMax()},
-                            auto value = it->value(yIndex);
+                            // y-axis range is converted to linear values
+                            QCPRange{std::pow(10, mesh.m_YMin), std::pow(10, mesh.yMax())});
-                            colormap->data()->setCell(xIndex, yIndex, value);
+                        // Sets values
+                        auto index = 0;
+                        for (auto it = mesh.m_Data.begin(), end = mesh.m_Data.end(); it != end; ++it, ++index) {
+                            auto xIndex = index % mesh.m_NbX;
+                            auto yIndex = index / mesh.m_NbX;
-                            // Processing spectrogram data for display in QCustomPlot
+                            colormap->data()->setCell(xIndex, yIndex, *it);
-                            /// For the moment, we just make the NaN values to be transparent in the colormap
-                            /// @todo ALX: complete treatments (mesh generation, etc.)
+                            // Makes the NaN values to be transparent in the colormap
-                            if (std::isnan(value)) {
+                            if (std::isnan(*it)) {
                                 colormap->data()->setAlpha(xIndex, yIndex, 0);
                             }
                         }
                     }
-                    dataSeries.unlock();
                     // Rescales axes
                     auto plot = colormap->parentPlot();
                     if (rescaleAxes) {
                         plot->rescaleAxes();
                     }
                     plot->replot();
                 }
             };
             /**
              * Helper used to create/update plottables
              */
             struct IPlottablesHelper {
                 virtual ~IPlottablesHelper() noexcept = default;
                 virtual PlottablesMap create(QCustomPlot &plot) const = 0;
                 virtual void setYAxisRange(const SqpRange &xAxisRange, QCustomPlot &plot) const = 0;
                 virtual void update(PlottablesMap &plottables, const SqpRange &range,
                                     bool rescaleAxes = false) const = 0;
             };
             /**
              * Default implementation of IPlottablesHelper, which takes data series to create/update plottables
              * @tparam T the data series' type
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper {
                 explicit PlottablesHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
                 PlottablesMap create(QCustomPlot &plot) const override
                 {
                     return PlottablesCreator<T>::createPlottables(m_DataSeries, plot);
                 }
                 void update(PlottablesMap &plottables, const SqpRange &range, bool rescaleAxes) const override
                 {
                     PlottablesUpdater<T>::updatePlottables(m_DataSeries, plottables, range, rescaleAxes);
                 }
                 void setYAxisRange(const SqpRange &xAxisRange, QCustomPlot &plot) const override
                 {
                     return PlottablesUpdater<T>::setPlotYAxisRange(m_DataSeries, xAxisRange, plot);
                 }
                 T &m_DataSeries;
             };
             /// Creates IPlottablesHelper according to a data series
             std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
                     return std::make_unique<PlottablesHelper<ScalarSeries> >(*scalarSeries);
                 }
                 else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
                     return std::make_unique<PlottablesHelper<SpectrogramSeries> >(*spectrogramSeries);
                 }
                 else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
                     return std::make_unique<PlottablesHelper<VectorSeries> >(*vectorSeries);
                 }
                 else {
                     return std::make_unique<PlottablesHelper<IDataSeries> >(*dataSeries);
                 }
             }
             } // namespace
             PlottablesMap VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
                                                            QCustomPlot &plot) noexcept
             {
                 if (variable) {
                     auto helper = createHelper(variable->dataSeries());
                     auto plottables = helper->create(plot);
                     return plottables;
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                     return PlottablesMap{};
                 }
             }
             void VisualizationGraphHelper::setYAxisRange(std::shared_ptr<Variable> variable,
                                                          QCustomPlot &plot) noexcept
             {
                 if (variable) {
                     auto helper = createHelper(variable->dataSeries());
                     helper->setYAxisRange(variable->range(), plot);
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't set y-axis range of plot: the variable is null");
                 }
             }
             void VisualizationGraphHelper::updateData(PlottablesMap &plottables,
                                                       std::shared_ptr<IDataSeries> dataSeries,
                                                       const SqpRange &dateTime)
             {
                 auto helper = createHelper(dataSeries);
                 helper->update(plottables, dateTime);
             }

plugins/amda/include/AmdaResultParserDefs.h +8 0

             #ifndef SCIQLOP_AMDARESULTPARSERDEFS_H
             #define SCIQLOP_AMDARESULTPARSERDEFS_H
             #include <QtCore/QRegularExpression>
             #include <QtCore/QString>
             #include <QtCore/QVariantHash>
             // ////////// //
             // Properties //
             // ////////// //
             /// Alias to represent properties read in the header of AMDA file
             using Properties = QVariantHash;
+            extern const QString END_TIME_PROPERTY;
             extern const QString FILL_VALUE_PROPERTY;
             extern const QString MAX_BANDS_PROPERTY;
             extern const QString MIN_BANDS_PROPERTY;
             extern const QString MAX_SAMPLING_PROPERTY;
             extern const QString MIN_SAMPLING_PROPERTY;
+            extern const QString START_TIME_PROPERTY;
             extern const QString X_AXIS_UNIT_PROPERTY;
             extern const QString Y_AXIS_UNIT_PROPERTY;
             extern const QString VALUES_UNIT_PROPERTY;
             // /////////////////// //
             // Regular expressions //
             // /////////////////// //
             // AMDA V2
             // /// Regex to find the header of the data in the file. This header indicates the end of comments
             // in the file
             // const auto DATA_HEADER_REGEX = QRegularExpression{QStringLiteral("#\\s*DATA\\s*:")};
             // AMDA V2
             // /// ... PARAMETER_UNITS : nT ...
             // /// ... PARAMETER_UNITS:nT ...
             // /// ... PARAMETER_UNITS:   m² ...
             // /// ... PARAMETER_UNITS : m/s ...
             // const auto UNIT_REGEX = QRegularExpression{QStringLiteral("\\s*PARAMETER_UNITS\\s*:\\s*(.+)")};
             /// Regex to find x-axis unit in a line. Examples of valid lines:
             /// ... - Units : nT - ...
             /// ... -Units:nT- ...
             /// ... -Units:   m²- ...
             /// ... - Units : m/s - ...
             extern const QRegularExpression DEFAULT_X_AXIS_UNIT_REGEX;
+            /// Regex to find end time of data in a line for a spectrogram
+            extern const QRegularExpression SPECTROGRAM_END_TIME_REGEX;
             /// Regex to find fill value used in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_FILL_VALUE_REGEX;
             /// Regex to find max bands in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_MAX_BANDS_REGEX;
             /// Regex to find min bands in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_MIN_BANDS_REGEX;
             /// Regex to find max x-axis sampling in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_MAX_SAMPLING_REGEX;
             /// Regex to find min x-axis sampling in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_MIN_SAMPLING_REGEX;
+            /// Regex to find start time of data in a line for a spectrogram
+            extern const QRegularExpression SPECTROGRAM_START_TIME_REGEX;
             /// Regex to find y-axis unit in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_Y_AXIS_UNIT_REGEX;
             /// Regex to find values unit in a line for a spectrogram
             extern const QRegularExpression SPECTROGRAM_VALUES_UNIT_REGEX;
             #endif // SCIQLOP_AMDARESULTPARSERDEFS_H

plugins/amda/include/AmdaResultParserHelper.h +2 0

             #ifndef SCIQLOP_AMDARESULTPARSERHELPER_H
             #define SCIQLOP_AMDARESULTPARSERHELPER_H
             #include "AmdaResultParserDefs.h"
             #include <QtCore/QLoggingCategory>
             #include <QtCore/QString>
             #include <memory>
             class IDataSeries;
             Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaResultParserHelper)
             /**
              * Helper used to interpret the data of an AMDA result file and generate the corresponding data
              * series.
              *
              * It proposes methods allowing to read line by line an AMDA file and to extract the properties
              * (from the header) and the values corresponding to the data series
              *
              * @sa DataSeries
              */
             struct IAmdaResultParserHelper {
                 virtual ~IAmdaResultParserHelper() noexcept = default;
                 /// Verifies that the extracted properties are well formed and possibly applies other treatments
                 /// on them
                 /// @return true if the properties are well formed, false otherwise
                 virtual bool checkProperties() = 0;
                 /// Creates the data series from the properties and values extracted from the AMDA file.
                 /// @warning as the data are moved in the data series, the helper shouldn't be used after
                 /// calling this method
                 /// @return the data series created
                 virtual std::shared_ptr<IDataSeries> createSeries() = 0;
                 /// Reads a line from the AMDA file to extract a property that will be used to generate the data
                 /// series
                 /// @param line tahe line to interpret
                 virtual void readPropertyLine(const QString &line) = 0;
                 /// Reads a line from the AMDA file to extract a value that will be set in the data series
                 /// @param line the line to interpret
                 virtual void readResultLine(const QString &line) = 0;
             };
             /**
              * Implementation of @sa IAmdaResultParserHelper for scalars
              */
             class ScalarParserHelper : public IAmdaResultParserHelper {
             public:
                 bool checkProperties() override;
                 std::shared_ptr<IDataSeries> createSeries() override;
                 void readPropertyLine(const QString &line) override;
                 void readResultLine(const QString &line) override;
             private:
                 /// @return the reading order of the "value" columns for a result line of the AMDA file
                 std::vector<int> valuesIndexes() const;
                 Properties m_Properties{};
                 std::vector<double> m_XAxisData{};
                 std::vector<double> m_ValuesData{};
             };
             /**
              * Implementation of @sa IAmdaResultParserHelper for spectrograms
              */
             class SpectrogramParserHelper : public IAmdaResultParserHelper {
             public:
                 bool checkProperties() override;
                 std::shared_ptr<IDataSeries> createSeries() override;
                 void readPropertyLine(const QString &line) override;
                 void readResultLine(const QString &line) override;
             private:
+                void handleDataHoles();
                 Properties m_Properties{};
                 std::vector<double> m_XAxisData{};
                 std::vector<double> m_YAxisData{};
                 std::vector<double> m_ValuesData{};
                 std::vector<int> m_ValuesIndexes{};
                 double m_FillValue{std::numeric_limits<double>::quiet_NaN()};
             };
             /**
              * Implementation of @sa IAmdaResultParserHelper for vectors
              */
             class VectorParserHelper : public IAmdaResultParserHelper {
             public:
                 bool checkProperties() override;
                 std::shared_ptr<IDataSeries> createSeries() override;
                 void readPropertyLine(const QString &line) override;
                 void readResultLine(const QString &line) override;
             private:
                 /// @return the reading order of the "value" columns for a result line of the AMDA file
                 std::vector<int> valuesIndexes() const;
                 Properties m_Properties{};
                 std::vector<double> m_XAxisData{};
                 std::vector<double> m_ValuesData{};
             };
             #endif // SCIQLOP_AMDARESULTPARSERHELPER_H

plugins/amda/src/AmdaResultParserDefs.cpp +8 0

             #include "AmdaResultParserDefs.h"
+            const QString END_TIME_PROPERTY = QStringLiteral("endTime");
             const QString FILL_VALUE_PROPERTY = QStringLiteral("fillValue");
             const QString MAX_BANDS_PROPERTY = QStringLiteral("maxBands");
             const QString MIN_BANDS_PROPERTY = QStringLiteral("minBands");
             const QString MAX_SAMPLING_PROPERTY = QStringLiteral("maxSampling");
             const QString MIN_SAMPLING_PROPERTY = QStringLiteral("minSampling");
+            const QString START_TIME_PROPERTY = QStringLiteral("startTime");
             const QString X_AXIS_UNIT_PROPERTY = QStringLiteral("xAxisUnit");
             const QString Y_AXIS_UNIT_PROPERTY = QStringLiteral("yAxisUnit");
             const QString VALUES_UNIT_PROPERTY = QStringLiteral("valuesUnit");
             const QRegularExpression DEFAULT_X_AXIS_UNIT_REGEX
                 = QRegularExpression{QStringLiteral("-\\s*Units\\s*:\\s*(.+?)\\s*-")};
+            const QRegularExpression SPECTROGRAM_END_TIME_REGEX
+                = QRegularExpression{QStringLiteral("\\s*INTERVAL_STOP\\s*:\\s*(.*)")};
             const QRegularExpression SPECTROGRAM_FILL_VALUE_REGEX
                 = QRegularExpression{QStringLiteral("\\s*PARAMETER_FILL_VALUE\\s*:\\s*(.*)")};
             const QRegularExpression SPECTROGRAM_MAX_BANDS_REGEX
                 = QRegularExpression{QStringLiteral("\\s*PARAMETER_TABLE_MAX_VALUES\\[0\\]\\s*:\\s*(.*)")};
             const QRegularExpression SPECTROGRAM_MIN_BANDS_REGEX
                 = QRegularExpression{QStringLiteral("\\s*PARAMETER_TABLE_MIN_VALUES\\[0\\]\\s*:\\s*(.*)")};
             const QRegularExpression SPECTROGRAM_MAX_SAMPLING_REGEX
                 = QRegularExpression{QStringLiteral("\\s*DATASET_MAX_SAMPLING\\s*:\\s*(.*)")};
             const QRegularExpression SPECTROGRAM_MIN_SAMPLING_REGEX
                 = QRegularExpression{QStringLiteral("\\s*DATASET_MIN_SAMPLING\\s*:\\s*(.*)")};
+            const QRegularExpression SPECTROGRAM_START_TIME_REGEX
+                = QRegularExpression{QStringLiteral("\\s*INTERVAL_START\\s*:\\s*(.*)")};
             const QRegularExpression SPECTROGRAM_Y_AXIS_UNIT_REGEX
                 = QRegularExpression{QStringLiteral("\\s*PARAMETER_TABLE_UNITS\\[0\\]\\s*:\\s*(.*)")};
             const QRegularExpression SPECTROGRAM_VALUES_UNIT_REGEX
                 = QRegularExpression{QStringLiteral("\\s*PARAMETER_UNITS\\s*:\\s*(.*)")};

plugins/amda/src/AmdaResultParserHelper.cpp +40 -4

             #include "AmdaResultParserHelper.h"
             #include <Common/DateUtils.h>
             #include <Common/SortUtils.h>
+            #include <Data/DataSeriesUtils.h>
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/Unit.h>
             #include <Data/VectorSeries.h>
             #include <QtCore/QDateTime>
             #include <QtCore/QRegularExpression>
             #include <functional>
             Q_LOGGING_CATEGORY(LOG_AmdaResultParserHelper, "AmdaResultParserHelper")
             namespace {
             // ///////// //
             // Constants //
             // ///////// //
             /// Separator between values in a result line
             const auto RESULT_LINE_SEPARATOR = QRegularExpression{QStringLiteral("\\s+")};
             /// Format for dates in result files
             const auto DATE_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss.zzz");
             // /////// //
             // Methods //
             // /////// //
             /**
              * Checks that the properties contain a specific unit and that this unit is valid
              * @param properties the properties map in which to search unit
              * @param key the key to search for the unit in the properties
              * @param errorMessage the error message to log in case the unit is invalid
              * @return true if the unit is valid, false it it's invalid or was not found in the properties
              */
             bool checkUnit(const Properties &properties, const QString &key, const QString &errorMessage)
             {
                 auto unit = properties.value(key).value<Unit>();
                 if (unit.m_Name.isEmpty()) {
                     qCWarning(LOG_AmdaResultParserHelper()) << errorMessage;
                     return false;
                 }
                 return true;
             }
             QDateTime dateTimeFromString(const QString &stringDate) noexcept
             {
             #if QT_VERSION >= QT_VERSION_CHECK(5, 8, 0)
                 return QDateTime::fromString(stringDate, Qt::ISODateWithMs);
             #else
                 return QDateTime::fromString(stringDate, DATE_FORMAT);
             #endif
             }
             /// Converts a string date to a double date
             /// @return a double that represents the date in seconds, NaN if the string date can't be converted
             double doubleDate(const QString &stringDate) noexcept
             {
                 // Format: yyyy-MM-ddThh:mm:ss.zzz
                 auto dateTime = dateTimeFromString(stringDate);
                 dateTime.setTimeSpec(Qt::UTC);
                 return dateTime.isValid() ? DateUtils::secondsSinceEpoch(dateTime)
                                           : std::numeric_limits<double>::quiet_NaN();
             }
             /**
              * Reads a line from the AMDA file and tries to extract a x-axis data and value data from it
              * @param xAxisData the vector in which to store the x-axis data extracted
              * @param valuesData the vector in which to store the value extracted
              * @param line the line to read to extract the property
              * @param valuesIndexes indexes of insertion of read values. For example, if the line contains three
              * columns of values, and valuesIndexes are {2, 0, 1}, the value of the third column will be read
              * and inserted first, then the value of the first column, and finally the value of the second
              * column.
              * @param fillValue value that tags an invalid data. For example, if fillValue is -1 and a read
              * value is -1, then this value is considered as invalid and converted to NaN
              */
             void tryReadResult(std::vector<double> &xAxisData, std::vector<double> &valuesData,
                                const QString &line, const std::vector<int> &valuesIndexes,
                                double fillValue = std::numeric_limits<double>::quiet_NaN())
             {
                 auto lineData = line.split(RESULT_LINE_SEPARATOR, QString::SkipEmptyParts);
                 // Checks that the line contains expected number of values + x-axis value
                 if (static_cast<size_t>(lineData.size()) == valuesIndexes.size() + 1) {
                     // X : the data is converted from date to double (in secs)
                     auto x = doubleDate(lineData.at(0));
                     // Adds result only if x is valid. Then, if value is invalid, it is set to NaN
                     if (!std::isnan(x)) {
                         xAxisData.push_back(x);
                         // Values
                         for (auto valueIndex : valuesIndexes) {
                             bool valueOk;
                             // we use valueIndex + 1 to skip column 0 (x-axis value)
                             auto value = lineData.at(valueIndex + 1).toDouble(&valueOk);
                             if (!valueOk) {
                                 qCWarning(LOG_AmdaResultParserHelper())
                                     << QObject::tr(
                                            "Value from (line %1, column %2) is invalid and will be "
                                            "converted to NaN")
                                            .arg(line, valueIndex);
                                 value = std::numeric_limits<double>::quiet_NaN();
                             }
                             // Handles fill value
                             if (!std::isnan(fillValue) && !std::isnan(value) && fillValue == value) {
                                 value = std::numeric_limits<double>::quiet_NaN();
                             }
                             valuesData.push_back(value);
                         }
                     }
                     else {
                         qCWarning(LOG_AmdaResultParserHelper())
                             << QObject::tr("Can't retrieve results from line %1: x is invalid").arg(line);
                     }
                 }
                 else {
                     qCWarning(LOG_AmdaResultParserHelper())
                         << QObject::tr("Can't retrieve results from line %1: invalid line").arg(line);
                 }
             }
             /**
              * Reads a line from the AMDA file and tries to extract a property from it
              * @param properties the properties map in which to put the property extracted from the line
              * @param key the key to which the property is added in the properties map
              * @param line the line to read to extract the property
              * @param regex the expected regex to extract the property. If the line matches this regex, the
              * property is generated
              * @param fun the function used to generate the property
              * @return true if the property could be generated, false if the line does not match the regex, or
              * if a property has already been generated for the key
              */
             template <typename GeneratePropertyFun>
             bool tryReadProperty(Properties &properties, const QString &key, const QString &line,
                                  const QRegularExpression &regex, GeneratePropertyFun fun)
             {
                 if (properties.contains(key)) {
                     return false;
                 }
                 auto match = regex.match(line);
                 if (match.hasMatch()) {
                     properties.insert(key, fun(match));
                 }
                 return match.hasMatch();
             }
             /**
+             * Reads a line from the AMDA file and tries to extract a data from it. Date is converted to double
+             * @sa tryReadProperty()
+             */
+            bool tryReadDate(Properties &properties, const QString &key, const QString &line,
+                             const QRegularExpression &regex, bool timeUnit = false)
+            {
+                return tryReadProperty(properties, key, line, regex, [timeUnit](const auto &match) {
+                    return QVariant::fromValue(doubleDate(match.captured(1)));
+                });
+            }
+            /**
              * Reads a line from the AMDA file and tries to extract a double from it
              * @sa tryReadProperty()
              */
             bool tryReadDouble(Properties &properties, const QString &key, const QString &line,
                                const QRegularExpression &regex)
             {
                 return tryReadProperty(properties, key, line, regex, [](const auto &match) {
                     bool ok;
                     // If the value can't be converted to double, it is set to NaN
                     auto doubleValue = match.captured(1).toDouble(&ok);
                     if (!ok) {
                         doubleValue = std::numeric_limits<double>::quiet_NaN();
                     }
                     return QVariant::fromValue(doubleValue);
                 });
             }
             /**
              * Reads a line from the AMDA file and tries to extract a vector of doubles from it
              * @param sep the separator of double values in the line
              * @sa tryReadProperty()
              */
             bool tryReadDoubles(Properties &properties, const QString &key, const QString &line,
                                 const QRegularExpression &regex, const QString &sep = QStringLiteral(","))
             {
                 return tryReadProperty(properties, key, line, regex, [sep](const auto &match) {
                     std::vector<double> doubleValues{};
                     // If the value can't be converted to double, it is set to NaN
                     auto values = match.captured(1).split(sep);
                     for (auto value : values) {
                         bool ok;
                         auto doubleValue = value.toDouble(&ok);
                         if (!ok) {
                             doubleValue = std::numeric_limits<double>::quiet_NaN();
                         }
                         doubleValues.push_back(doubleValue);
                     }
                     return QVariant::fromValue(doubleValues);
                 });
             }
             /**
              * Reads a line from the AMDA file and tries to extract a unit from it
              * @sa tryReadProperty()
              */
             bool tryReadUnit(Properties &properties, const QString &key, const QString &line,
                              const QRegularExpression &regex, bool timeUnit = false)
             {
                 return tryReadProperty(properties, key, line, regex, [timeUnit](const auto &match) {
                     return QVariant::fromValue(Unit{match.captured(1), timeUnit});
                 });
             }
             } // namespace
             // ////////////////// //
             // ScalarParserHelper //
             // ////////////////// //
             bool ScalarParserHelper::checkProperties()
             {
                 return checkUnit(m_Properties, X_AXIS_UNIT_PROPERTY,
                                  QObject::tr("The x-axis unit could not be found in the file"));
             }
             std::shared_ptr<IDataSeries> ScalarParserHelper::createSeries()
             {
                 return std::make_shared<ScalarSeries>(std::move(m_XAxisData), std::move(m_ValuesData),
                                                       m_Properties.value(X_AXIS_UNIT_PROPERTY).value<Unit>(),
                                                       m_Properties.value(VALUES_UNIT_PROPERTY).value<Unit>());
             }
             void ScalarParserHelper::readPropertyLine(const QString &line)
             {
                 tryReadUnit(m_Properties, X_AXIS_UNIT_PROPERTY, line, DEFAULT_X_AXIS_UNIT_REGEX, true);
             }
             void ScalarParserHelper::readResultLine(const QString &line)
             {
                 tryReadResult(m_XAxisData, m_ValuesData, line, valuesIndexes());
             }
             std::vector<int> ScalarParserHelper::valuesIndexes() const
             {
                 // Only one value to read
                 static auto result = std::vector<int>{0};
                 return result;
             }
             // /////////////////////// //
             // SpectrogramParserHelper //
             // /////////////////////// //
             bool SpectrogramParserHelper::checkProperties()
             {
                 // Generates y-axis data from bands extracted (take the middle of the intervals)
                 auto minBands = m_Properties.value(MIN_BANDS_PROPERTY).value<std::vector<double> >();
                 auto maxBands = m_Properties.value(MAX_BANDS_PROPERTY).value<std::vector<double> >();
-                if (minBands.size() != maxBands.size()) {
+                if (minBands.size() < 2 || minBands.size() != maxBands.size()) {
                     qCWarning(LOG_AmdaResultParserHelper()) << QObject::tr(
                         "Can't generate y-axis data from bands extracted: bands intervals are invalid");
                     return false;
                 }
                 std::transform(
                     minBands.begin(), minBands.end(), maxBands.begin(), std::back_inserter(m_YAxisData),
                     [](const auto &minValue, const auto &maxValue) { return (minValue + maxValue) / 2.; });
                 // Generates values indexes, i.e. the order in which each value will be retrieved (in ascending
                 // order of the associated bands)
                 m_ValuesIndexes = SortUtils::sortPermutation(m_YAxisData, std::less<double>());
                 // Sorts y-axis data accoding to the ascending order
                 m_YAxisData = SortUtils::sort(m_YAxisData, 1, m_ValuesIndexes);
                 // Sets fill value
                 m_FillValue = m_Properties.value(FILL_VALUE_PROPERTY).value<double>();
-                /// @todo: handle min/max samplings?
                 return true;
             }
             std::shared_ptr<IDataSeries> SpectrogramParserHelper::createSeries()
             {
+                // Before creating the series, we handle its data holes
+                handleDataHoles();
                 return std::make_shared<SpectrogramSeries>(
                     std::move(m_XAxisData), std::move(m_YAxisData), std::move(m_ValuesData),
                     Unit{"t", true}, // x-axis unit is always a time unit
                     m_Properties.value(Y_AXIS_UNIT_PROPERTY).value<Unit>(),
-                    m_Properties.value(VALUES_UNIT_PROPERTY).value<Unit>());
+                    m_Properties.value(VALUES_UNIT_PROPERTY).value<Unit>(),
+                    m_Properties.value(MIN_SAMPLING_PROPERTY).value<double>());
             }
             void SpectrogramParserHelper::readPropertyLine(const QString &line)
             {
                 // Set of functions to test on the line to generate a property. If a function is valid (i.e. a
                 // property has been generated for the line), the line is treated as processed and the other
                 // functions are not called
                 std::vector<std::function<bool()> > functions{
                     // values unit
                     [&] {
                         return tryReadUnit(m_Properties, VALUES_UNIT_PROPERTY, line,
                                            SPECTROGRAM_VALUES_UNIT_REGEX);
                     },
                     // y-axis unit
                     [&] {
                         return tryReadUnit(m_Properties, Y_AXIS_UNIT_PROPERTY, line,
                                            SPECTROGRAM_Y_AXIS_UNIT_REGEX);
                     },
                     // min sampling
                     [&] {
                         return tryReadDouble(m_Properties, MIN_SAMPLING_PROPERTY, line,
                                              SPECTROGRAM_MIN_SAMPLING_REGEX);
                     },
                     // max sampling
                     [&] {
                         return tryReadDouble(m_Properties, MAX_SAMPLING_PROPERTY, line,
                                              SPECTROGRAM_MAX_SAMPLING_REGEX);
                     },
                     // fill value
                     [&] {
                         return tryReadDouble(m_Properties, FILL_VALUE_PROPERTY, line,
                                              SPECTROGRAM_FILL_VALUE_REGEX);
                     },
                     // min bounds of each band
                     [&] {
                         return tryReadDoubles(m_Properties, MIN_BANDS_PROPERTY, line,
                                               SPECTROGRAM_MIN_BANDS_REGEX);
                     },
                     // max bounds of each band
                     [&] {
                         return tryReadDoubles(m_Properties, MAX_BANDS_PROPERTY, line,
                                               SPECTROGRAM_MAX_BANDS_REGEX);
+                    },
+                    // start time of data
+                    [&] {
+                        return tryReadDate(m_Properties, START_TIME_PROPERTY, line,
+                                           SPECTROGRAM_START_TIME_REGEX);
+                    },
+                    // end time of data
+                    [&] {
+                        return tryReadDate(m_Properties, END_TIME_PROPERTY, line, SPECTROGRAM_END_TIME_REGEX);
                     }};
                 for (auto function : functions) {
                     // Stops at the first function that is valid
                     if (function()) {
                         return;
                     }
                 }
             }
             void SpectrogramParserHelper::readResultLine(const QString &line)
             {
                 tryReadResult(m_XAxisData, m_ValuesData, line, m_ValuesIndexes, m_FillValue);
             }
+            void SpectrogramParserHelper::handleDataHoles()
+            {
+                // Fills data holes according to the max resolution found in the AMDA file
+                auto resolution = m_Properties.value(MAX_SAMPLING_PROPERTY).value<double>();
+                auto fillValue = m_Properties.value(FILL_VALUE_PROPERTY).value<double>();
+                auto minBound = m_Properties.value(START_TIME_PROPERTY).value<double>();
+                auto maxBound = m_Properties.value(END_TIME_PROPERTY).value<double>();
+                DataSeriesUtils::fillDataHoles(m_XAxisData, m_ValuesData, resolution, fillValue, minBound,
+                                               maxBound);
+            }
             // ////////////////// //
             // VectorParserHelper //
             // ////////////////// //
             bool VectorParserHelper::checkProperties()
             {
                 return checkUnit(m_Properties, X_AXIS_UNIT_PROPERTY,
                                  QObject::tr("The x-axis unit could not be found in the file"));
             }
             std::shared_ptr<IDataSeries> VectorParserHelper::createSeries()
             {
                 return std::make_shared<VectorSeries>(std::move(m_XAxisData), std::move(m_ValuesData),
                                                       m_Properties.value(X_AXIS_UNIT_PROPERTY).value<Unit>(),
                                                       m_Properties.value(VALUES_UNIT_PROPERTY).value<Unit>());
             }
             void VectorParserHelper::readPropertyLine(const QString &line)
             {
                 tryReadUnit(m_Properties, X_AXIS_UNIT_PROPERTY, line, DEFAULT_X_AXIS_UNIT_REGEX, true);
             }
             void VectorParserHelper::readResultLine(const QString &line)
             {
                 tryReadResult(m_XAxisData, m_ValuesData, line, valuesIndexes());
             }
             std::vector<int> VectorParserHelper::valuesIndexes() const
             {
                 // 3 values to read, in order in the file (x, y, z)
                 static auto result = std::vector<int>{0, 1, 2};
                 return result;
             }

plugins/amda/tests/TestAmdaResultParser.cpp +133 -5

             #include "AmdaResultParser.h"
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <QObject>
             #include <QtTest>
             namespace {
             /// Path for the tests
             const auto TESTS_RESOURCES_PATH
                 = QFileInfo{QString{AMDA_TESTS_RESOURCES_DIR}, "TestAmdaResultParser"}.absoluteFilePath();
             QDateTime dateTime(int year, int month, int day, int hours, int minutes, int seconds)
             {
                 return QDateTime{{year, month, day}, {hours, minutes, seconds}, Qt::UTC};
             }
             QString inputFilePath(const QString &inputFileName)
             {
                 return QFileInfo{TESTS_RESOURCES_PATH, inputFileName}.absoluteFilePath();
             }
             template <typename T>
             struct ExpectedResults {
                 ExpectedResults &setParsingOK(bool parsingOK)
                 {
                     m_ParsingOK = parsingOK;
                     return *this;
                 }
                 ExpectedResults &setXAxisUnit(Unit xAxisUnit)
                 {
                     m_XAxisUnit = std::move(xAxisUnit);
                     return *this;
                 }
                 ExpectedResults &setXAxisData(const QVector<QDateTime> &xAxisData)
                 {
                     m_XAxisData.clear();
                     // Converts QVector<QDateTime> to QVector<double>
                     std::transform(xAxisData.cbegin(), xAxisData.cend(), std::back_inserter(m_XAxisData),
                                    [](const auto &dateTime) { return dateTime.toMSecsSinceEpoch() / 1000.; });
                     return *this;
                 }
                 ExpectedResults &setValuesUnit(Unit valuesUnit)
                 {
                     m_ValuesUnit = std::move(valuesUnit);
                     return *this;
                 }
                 ExpectedResults &setValuesData(QVector<double> valuesData)
                 {
                     m_ValuesData.clear();
                     m_ValuesData.push_back(std::move(valuesData));
                     return *this;
                 }
                 ExpectedResults &setValuesData(QVector<QVector<double> > valuesData)
                 {
                     m_ValuesData = std::move(valuesData);
                     return *this;
                 }
                 ExpectedResults &setYAxisEnabled(bool yAxisEnabled)
                 {
                     m_YAxisEnabled = yAxisEnabled;
                     return *this;
                 }
                 ExpectedResults &setYAxisUnit(Unit yAxisUnit)
                 {
                     m_YAxisUnit = std::move(yAxisUnit);
                     return *this;
                 }
                 ExpectedResults &setYAxisData(QVector<double> yAxisData)
                 {
                     m_YAxisData = std::move(yAxisData);
                     return *this;
                 }
                 /**
                  * Validates a DataSeries compared to the expected results
                  * @param results the DataSeries to validate
                  */
                 void validate(std::shared_ptr<IDataSeries> results)
                 {
                     if (m_ParsingOK) {
                         auto dataSeries = dynamic_cast<T *>(results.get());
                         if (dataSeries == nullptr) {
                             // No unit detected, parsink ok but data is nullptr
                             // TODO, improve the test to verify that the data is null
                             return;
                         }
                         // Checks units
                         QVERIFY(dataSeries->xAxisUnit() == m_XAxisUnit);
                         QVERIFY(dataSeries->valuesUnit() == m_ValuesUnit);
                         auto verifyRange = [dataSeries](const auto &expectedData, const auto &equalFun) {
                             QVERIFY(std::equal(dataSeries->cbegin(), dataSeries->cend(), expectedData.cbegin(),
                                                expectedData.cend(),
                                                [&equalFun](const auto &dataSeriesIt, const auto &expectedX) {
                                                    return equalFun(dataSeriesIt, expectedX);
                                                }));
                         };
                         // Checks x-axis data
                         verifyRange(m_XAxisData, [](const auto &seriesIt, const auto &value) {
                             return seriesIt.x() == value;
                         });
                         // Checks values data of each component
                         for (auto i = 0; i < m_ValuesData.size(); ++i) {
                             verifyRange(m_ValuesData.at(i), [i](const auto &seriesIt, const auto &value) {
                                 auto itValue = seriesIt.value(i);
                                 return (std::isnan(itValue) && std::isnan(value)) || seriesIt.value(i) == value;
                             });
                         }
                         // Checks y-axis (if defined)
                         auto yAxis = dataSeries->yAxis();
                         QCOMPARE(yAxis.isDefined(), m_YAxisEnabled);
                         if (m_YAxisEnabled) {
                             // Unit
                             QCOMPARE(yAxis.unit(), m_YAxisUnit);
                             // Data
-                            auto yAxisSize = yAxis.size();
+                            QVERIFY(std::equal(yAxis.cbegin(), yAxis.cend(), m_YAxisData.cbegin(),
-                            QCOMPARE(yAxisSize, m_YAxisData.size());
+                                               m_YAxisData.cend(), [](const auto &it, const auto &expectedVal) {
-                            for (auto i = 0; i < yAxisSize; ++i) {
+                                                   return it.first() == expectedVal;
-                                QCOMPARE(yAxis.at(i), m_YAxisData.at(i));
+                                               }));
                         }
                     }
                     else {
                         QVERIFY(results == nullptr);
                     }
                 }
                 // Parsing was successfully completed
                 bool m_ParsingOK{false};
                 // Expected x-axis unit
                 Unit m_XAxisUnit{};
                 // Expected x-axis data
                 QVector<double> m_XAxisData{};
                 // Expected values unit
                 Unit m_ValuesUnit{};
                 // Expected values data
                 QVector<QVector<double> > m_ValuesData{};
                 // Expected data series has y-axis
                 bool m_YAxisEnabled{false};
                 // Expected y-axis unit (if axis defined)
                 Unit m_YAxisUnit{};
                 // Expected y-axis data (if axis defined)
                 QVector<double> m_YAxisData{};
             };
             } // namespace
             Q_DECLARE_METATYPE(ExpectedResults<ScalarSeries>)
             Q_DECLARE_METATYPE(ExpectedResults<SpectrogramSeries>)
             Q_DECLARE_METATYPE(ExpectedResults<VectorSeries>)
             class TestAmdaResultParser : public QObject {
                 Q_OBJECT
             private:
                 template <typename T>
                 void testReadDataStructure()
                 {
                     // ////////////// //
                     // Test structure //
                     // ////////////// //
                     // Name of TXT file to read
                     QTest::addColumn<QString>("inputFileName");
                     // Expected results
                     QTest::addColumn<ExpectedResults<T> >("expectedResults");
                 }
                 template <typename T>
                 void testRead(AmdaResultParser::ValueType valueType)
                 {
                     QFETCH(QString, inputFileName);
                     QFETCH(ExpectedResults<T>, expectedResults);
                     // Parses file
                     auto filePath = inputFilePath(inputFileName);
                     auto results = AmdaResultParser::readTxt(filePath, valueType);
                     // ///////////////// //
                     // Validates results //
                     // ///////////////// //
                     expectedResults.validate(results);
                 }
             private slots:
                 /// Input test data
                 /// @sa testReadScalarTxt()
                 void testReadScalarTxt_data();
                 /// Tests parsing scalar series of a TXT file
                 void testReadScalarTxt();
                 /// Input test data
                 /// @sa testReadSpectrogramTxt()
                 void testReadSpectrogramTxt_data();
                 /// Tests parsing spectrogram series of a TXT file
                 void testReadSpectrogramTxt();
                 /// Input test data
                 /// @sa testReadVectorTxt()
                 void testReadVectorTxt_data();
                 /// Tests parsing vector series of a TXT file
                 void testReadVectorTxt();
             };
             void TestAmdaResultParser::testReadScalarTxt_data()
             {
                 testReadDataStructure<ScalarSeries>();
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 // Valid files
                 QTest::newRow("Valid file")
                     << QStringLiteral("ValidScalar1.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                           dateTime(2013, 9, 23, 9, 2, 30), dateTime(2013, 9, 23, 9, 3, 30),
                                           dateTime(2013, 9, 23, 9, 4, 30), dateTime(2013, 9, 23, 9, 5, 30),
                                           dateTime(2013, 9, 23, 9, 6, 30), dateTime(2013, 9, 23, 9, 7, 30),
                                           dateTime(2013, 9, 23, 9, 8, 30), dateTime(2013, 9, 23, 9, 9, 30)})
                            .setValuesData({-2.83950, -2.71850, -2.52150, -2.57633, -2.58050, -2.48325, -2.63025,
                                            -2.55800, -2.43250, -2.42200});
                 QTest::newRow("Valid file (value of first line is invalid but it is converted to NaN")
                     << QStringLiteral("WrongValue.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                           dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({std::numeric_limits<double>::quiet_NaN(), -2.71850, -2.52150});
                 QTest::newRow("Valid file that contains NaN values")
                     << QStringLiteral("NaNValue.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{("nT"), true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                           dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({std::numeric_limits<double>::quiet_NaN(), -2.71850, -2.52150});
                 // Valid files but with some invalid lines (wrong unit, wrong values, etc.)
                 QTest::newRow("No unit file")
                     << QStringLiteral("NoUnit.txt")
                     << ExpectedResults<ScalarSeries>{}.setParsingOK(true).setXAxisUnit(Unit{"", true});
                 QTest::newRow("Wrong unit file")
                     << QStringLiteral("WrongUnit.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                           dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({-2.83950, -2.71850, -2.52150});
                 QTest::newRow("Wrong results file (date of first line is invalid")
                     << QStringLiteral("WrongDate.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({-2.71850, -2.52150});
                 QTest::newRow("Wrong results file (too many values for first line")
                     << QStringLiteral("TooManyValues.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({-2.71850, -2.52150});
                 QTest::newRow("Wrong results file (x of first line is NaN")
                     << QStringLiteral("NaNX.txt")
                     << ExpectedResults<ScalarSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)})
                            .setValuesData({-2.71850, -2.52150});
                 QTest::newRow("Invalid file type (vector)")
                     << QStringLiteral("ValidVector1.txt")
                     << ExpectedResults<ScalarSeries>{}.setParsingOK(true).setXAxisUnit(Unit{"nT", true});
                 // Invalid files
                 QTest::newRow("Invalid file (unexisting file)")
                     << QStringLiteral("UnexistingFile.txt")
                     << ExpectedResults<ScalarSeries>{}.setParsingOK(false);
                 QTest::newRow("Invalid file (file not found on server)")
                     << QStringLiteral("FileNotFound.txt")
                     << ExpectedResults<ScalarSeries>{}.setParsingOK(false);
             }
             void TestAmdaResultParser::testReadScalarTxt()
             {
                 testRead<ScalarSeries>(AmdaResultParser::ValueType::SCALAR);
             }
             void TestAmdaResultParser::testReadSpectrogramTxt_data()
             {
                 testReadDataStructure<SpectrogramSeries>();
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 // Valid files
                 QTest::newRow("Valid file (three bands)")
                     << QStringLiteral("spectro/ValidSpectrogram1.txt")
                     << ExpectedResults<SpectrogramSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"t", true})
                            .setXAxisData({dateTime(2012, 11, 6, 9, 14, 35), dateTime(2012, 11, 6, 9, 16, 10),
                                           dateTime(2012, 11, 6, 9, 17, 45), dateTime(2012, 11, 6, 9, 19, 20),
                                           dateTime(2012, 11, 6, 9, 20, 55)})
                            .setYAxisEnabled(true)
                            .setYAxisUnit(Unit{"eV"})
                            .setYAxisData({5.75, 7.6, 10.05}) // middle of the intervals of each band
                            .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
                            .setValuesData(QVector<QVector<double> >{
                                {16313.780, 12631.465, 8223.368, 27595.301, 12820.613},
                                {15405.838, 11957.925, 15026.249, 25617.533, 11179.109},
                                {8946.475, 18133.158, 10875.621, 24051.619, 19283.221}});
                 auto fourBandsResult
                     = ExpectedResults<SpectrogramSeries>{}
                           .setParsingOK(true)
                           .setXAxisUnit(Unit{"t", true})
                           .setXAxisData({dateTime(2012, 11, 6, 9, 14, 35), dateTime(2012, 11, 6, 9, 16, 10),
                                          dateTime(2012, 11, 6, 9, 17, 45), dateTime(2012, 11, 6, 9, 19, 20),
                                          dateTime(2012, 11, 6, 9, 20, 55)})
                           .setYAxisEnabled(true)
                           .setYAxisUnit(Unit{"eV"})
                           .setYAxisData({5.75, 7.6, 10.05, 13.}) // middle of the intervals of each band
                           .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
                           .setValuesData(QVector<QVector<double> >{
                               {16313.780, 12631.465, 8223.368, 27595.301, 12820.613},
                               {15405.838, 11957.925, 15026.249, 25617.533, 11179.109},
                               {8946.475, 18133.158, 10875.621, 24051.619, 19283.221},
                               {20907.664, 32076.725, 13008.381, 13142.759, 23226.998}});
                 QTest::newRow("Valid file (four bands)")
                     << QStringLiteral("spectro/ValidSpectrogram2.txt") << fourBandsResult;
                 QTest::newRow("Valid file (four unsorted bands)")
                     << QStringLiteral("spectro/ValidSpectrogram3.txt")
                     << fourBandsResult; // Bands and values are sorted
                 auto nan = std::numeric_limits<double>::quiet_NaN();
                 auto nanValuesResult
                     = ExpectedResults<SpectrogramSeries>{}
                           .setParsingOK(true)
                           .setXAxisUnit(Unit{"t", true})
                           .setXAxisData({dateTime(2012, 11, 6, 9, 14, 35), dateTime(2012, 11, 6, 9, 16, 10),
                                          dateTime(2012, 11, 6, 9, 17, 45), dateTime(2012, 11, 6, 9, 19, 20),
                                          dateTime(2012, 11, 6, 9, 20, 55)})
                           .setYAxisEnabled(true)
                           .setYAxisUnit(Unit{"eV"})
                           .setYAxisData({5.75, 7.6, 10.05, 13.}) // middle of the intervals of each band
                           .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
                           .setValuesData(
                               QVector<QVector<double> >{{nan, 12631.465, 8223.368, 27595.301, 12820.613},
                                                         {15405.838, nan, nan, 25617.533, 11179.109},
                                                         {8946.475, 18133.158, 10875.621, 24051.619, 19283.221},
                                                         {nan, nan, nan, nan, nan}});
                 QTest::newRow("Valid file (containing NaN values)")
                     << QStringLiteral("spectro/ValidSpectrogramNaNValues.txt") << nanValuesResult;
                 QTest::newRow("Valid file (containing fill values)")
                     << QStringLiteral("spectro/ValidSpectrogramFillValues.txt")
                     << nanValuesResult; // Fill values are replaced by NaN values in the data series
+                QTest::newRow("Valid file (containing data holes, resolution = 3 minutes)")
+                    << QStringLiteral("spectro/ValidSpectrogramDataHoles.txt")
+                    << ExpectedResults<SpectrogramSeries>{}
+                           .setParsingOK(true)
+                           .setXAxisUnit(Unit{"t", true})
+                           .setXAxisData({dateTime(2011, 12, 10, 12, 10, 54), //
+                                          dateTime(2011, 12, 10, 12, 13, 54), // Data hole
+                                          dateTime(2011, 12, 10, 12, 16, 54), // Data hole
+                                          dateTime(2011, 12, 10, 12, 17, 23), //
+                                          dateTime(2011, 12, 10, 12, 20, 23), // Data hole
+                                          dateTime(2011, 12, 10, 12, 23, 23), // Data hole
+                                          dateTime(2011, 12, 10, 12, 23, 51), //
+                                          dateTime(2011, 12, 10, 12, 26, 51), // Data hole
+                                          dateTime(2011, 12, 10, 12, 29, 51), // Data hole
+                                          dateTime(2011, 12, 10, 12, 30, 19), //
+                                          dateTime(2011, 12, 10, 12, 33, 19), // Data hole
+                                          dateTime(2011, 12, 10, 12, 35, 04), //
+                                          dateTime(2011, 12, 10, 12, 36, 41), //
+                                          dateTime(2011, 12, 10, 12, 38, 18), //
+                                          dateTime(2011, 12, 10, 12, 39, 55)})
+                           .setYAxisEnabled(true)
+                           .setYAxisUnit(Unit{"eV"})
+                           .setYAxisData({16485.85, 20996.1}) // middle of the intervals of each band
+                           .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
+                           .setValuesData(QVector<QVector<double> >{{2577578.000, //
+                                                                     nan,         // Data hole
+                                                                     nan,         // Data hole
+                                                                     2314121.500, //
+                                                                     nan,         // Data hole
+                                                                     nan,         // Data hole
+                                                                     2063608.750, //
+                                                                     nan,         // Data hole
+                                                                     nan,         // Data hole
+                                                                     2234525.500, //
+                                                                     nan,         // Data hole
+                                                                     1670215.250, //
+                                                                     1689243.250, //
+                                                                     1654617.125, //
+                                                                     1504983.750},
+                                                                    {2336016.000, //
+                                                                     nan,         // Data hole
+                                                                     nan,         // Data hole
+                                                                     1712093.125, //
+                                                                     nan,         // Data hole
+                                                                     nan,         // Data hole
+                                                                     1614491.625, //
+                                                                     nan,         // Data hole
+                                                                     nan,         // Data hole
+                                                                     1764516.500, //
+                                                                     nan,         // Data hole
+                                                                     1688078.500, //
+                                                                     1743183.500, //
+                                                                     1733603.250, //
+                                                                     1708356.500}});
+                QTest::newRow(
+                    "Valid file (containing data holes at the beginning and the end, resolution = 4 minutes)")
+                    << QStringLiteral("spectro/ValidSpectrogramDataHoles2.txt")
+                    << ExpectedResults<SpectrogramSeries>{}
+                           .setParsingOK(true)
+                           .setXAxisUnit(Unit{"t", true})
+                           .setXAxisData({
+                               dateTime(2011, 12, 10, 12, 2, 54),  // Data hole
+                               dateTime(2011, 12, 10, 12, 6, 54),  // Data hole
+                               dateTime(2011, 12, 10, 12, 10, 54), //
+                               dateTime(2011, 12, 10, 12, 14, 54), // Data hole
+                               dateTime(2011, 12, 10, 12, 17, 23), //
+                               dateTime(2011, 12, 10, 12, 21, 23), // Data hole
+                               dateTime(2011, 12, 10, 12, 23, 51), //
+                               dateTime(2011, 12, 10, 12, 27, 51), // Data hole
+                               dateTime(2011, 12, 10, 12, 30, 19), //
+                               dateTime(2011, 12, 10, 12, 34, 19), // Data hole
+                               dateTime(2011, 12, 10, 12, 35, 04), //
+                               dateTime(2011, 12, 10, 12, 36, 41), //
+                               dateTime(2011, 12, 10, 12, 38, 18), //
+                               dateTime(2011, 12, 10, 12, 39, 55),
+                               dateTime(2011, 12, 10, 12, 43, 55), // Data hole
+                               dateTime(2011, 12, 10, 12, 47, 55), // Data hole
+                               dateTime(2011, 12, 10, 12, 51, 55), // Data hole
+                               dateTime(2011, 12, 10, 12, 55, 55), // Data hole
+                               dateTime(2011, 12, 10, 12, 59, 55)  // Data hole
+                           })
+                           .setYAxisEnabled(true)
+                           .setYAxisUnit(Unit{"eV"})
+                           .setYAxisData({16485.85, 20996.1}) // middle of the intervals of each band
+                           .setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
+                           .setValuesData(QVector<QVector<double> >{{
+                                                                        nan,         // Data hole
+                                                                        nan,         // Data hole
+                                                                        2577578.000, //
+                                                                        nan,         // Data hole
+                                                                        2314121.500, //
+                                                                        nan,         // Data hole
+                                                                        2063608.750, //
+                                                                        nan,         // Data hole
+                                                                        2234525.500, //
+                                                                        nan,         // Data hole
+                                                                        1670215.250, //
+                                                                        1689243.250, //
+                                                                        1654617.125, //
+                                                                        1504983.750, //
+                                                                        nan,         // Data hole
+                                                                        nan,         // Data hole
+                                                                        nan,         // Data hole
+                                                                        nan,         // Data hole
+                                                                        nan          // Data hole
+                                                                    },
+                                                                    {
+                                                                        nan,         // Data hole
+                                                                        nan,         // Data hole
+                                                                        2336016.000, //
+                                                                        nan,         // Data hole
+                                                                        1712093.125, //
+                                                                        nan,         // Data hole
+                                                                        1614491.625, //
+                                                                        nan,         // Data hole
+                                                                        1764516.500, //
+                                                                        nan,         // Data hole
+                                                                        1688078.500, //
+                                                                        1743183.500, //
+                                                                        1733603.250, //
+                                                                        1708356.500, //
+                                                                        nan,         // Data hole
+                                                                        nan,         // Data hole
+                                                                        nan,         // Data hole
+                                                                        nan,         // Data hole
+                                                                        nan          // Data hole
+                                                                    }});
                 // Invalid files
                 QTest::newRow("Invalid file (inconsistent bands)")
                     << QStringLiteral("spectro/InvalidSpectrogramWrongBands.txt")
                     << ExpectedResults<SpectrogramSeries>{}.setParsingOK(false);
             }
             void TestAmdaResultParser::testReadSpectrogramTxt()
             {
                 testRead<SpectrogramSeries>(AmdaResultParser::ValueType::SPECTROGRAM);
             }
             void TestAmdaResultParser::testReadVectorTxt_data()
             {
                 testReadDataStructure<VectorSeries>();
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 // Valid files
                 QTest::newRow("Valid file")
                     << QStringLiteral("ValidVector1.txt")
                     << ExpectedResults<VectorSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({dateTime(2013, 7, 2, 9, 13, 50), dateTime(2013, 7, 2, 9, 14, 6),
                                           dateTime(2013, 7, 2, 9, 14, 22), dateTime(2013, 7, 2, 9, 14, 38),
                                           dateTime(2013, 7, 2, 9, 14, 54), dateTime(2013, 7, 2, 9, 15, 10),
                                           dateTime(2013, 7, 2, 9, 15, 26), dateTime(2013, 7, 2, 9, 15, 42),
                                           dateTime(2013, 7, 2, 9, 15, 58), dateTime(2013, 7, 2, 9, 16, 14)})
                            .setValuesData(
                                {{-0.332, -1.011, -1.457, -1.293, -1.217, -1.443, -1.278, -1.202, -1.22, -1.259},
                                 {3.206, 2.999, 2.785, 2.736, 2.612, 2.564, 2.892, 2.862, 2.859, 2.764},
                                 {0.058, 0.496, 1.018, 1.485, 1.662, 1.505, 1.168, 1.244, 1.15, 1.358}});
                 // Valid files but with some invalid lines (wrong unit, wrong values, etc.)
                 QTest::newRow("Invalid file type (scalar)")
                     << QStringLiteral("ValidScalar1.txt")
                     << ExpectedResults<VectorSeries>{}
                            .setParsingOK(true)
                            .setXAxisUnit(Unit{"nT", true})
                            .setXAxisData({})
                            .setValuesData(QVector<QVector<double> >{{}, {}, {}});
             }
             void TestAmdaResultParser::testReadVectorTxt()
             {
                 testRead<VectorSeries>(AmdaResultParser::ValueType::VECTOR);
             }
             QTEST_MAIN(TestAmdaResultParser)
             #include "TestAmdaResultParser.moc"

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