GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1041:bd6284620dee

Merge branch 'feature/SpectroMeshes' into develop

Alexandre Leroux -

r1041:bd6284620dee

parent child

Context file:

r1041: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

                 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()}
                 {
                 }
                 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()}
                 {
                 }
                 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;
                 }
                 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(); }
                     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
                 /// @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; }
                 int nbPoints() const override { return m_ValuesData->totalSize(); }
+                std::pair<double, double> yBounds() const override { return m_YAxis.bounds(); }
                 void clear()
                 {
                     m_XAxisData->clear();
                 }
                 /// @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 //

core/include/Data/DataSeriesIterator.h +3 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;
                 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

core/include/Data/IDataSeries.h +6 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;
                 /// @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 //
                 // ///////// //

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"
                 /// @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;
                 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

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

                 /// 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

               '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',

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

                 return m_Impl->x();
             }
+            std::vector<double> DataSeriesIteratorValue::y() const
+            {
+                return m_Impl->y();
+            }
             double DataSeriesIteratorValue::value() const
             {
                 return m_Impl->value();

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

@@ -2,7 +2,8
2		2
3	#include "Data/ArrayData.h"	3	#include "Data/ArrayData.h"
4		4
5	OptionalAxis::OptionalAxis() : m_Defined{false}, m_Data{nullptr}, m_Unit{}	5	OptionalAxis::OptionalAxis()
		6	: m_Defined{false}, m_Data{std::make_shared<ArrayData<1> >(std::vector<double>{})}, m_Unit{}
6	{	7	{
7	}	8	}
8		9
@@ -15,9 +16,7 OptionalAxis::OptionalAxis(std::shared_ptr<ArrayData<1> > data, Unit unit)
15	}	16	}
16		17
17	OptionalAxis::OptionalAxis(const OptionalAxis &other)	18	OptionalAxis::OptionalAxis(const OptionalAxis &other)
18	: m_Defined{other.m_Defined},	19	: m_Defined{other.m_Defined}, m_Data{other.m_Data}, m_Unit{other.m_Unit}
19	m_Data{other.m_Data ? std::make_shared<ArrayData<1> >(*other.m_Data) : nullptr},
20	m_Unit{other.m_Unit}
21	{	20	{
22	}	21	}
23		22
@@ -35,17 +34,6 bool OptionalAxis::isDefined() const
35	return m_Defined;	34	return m_Defined;
36	}	35	}
37		36
38	double OptionalAxis::at(int index) const
39	{
40	if (m_Defined) {
41	return (index >= 0 && index < m_Data->size()) ? m_Data->at(index)
42	: std::numeric_limits<double>::quiet_NaN();
43	}
44	else {
45	return std::numeric_limits<double>::quiet_NaN();
46	}
47	}
48
49	std::pair<double, double> OptionalAxis::bounds() const	37	std::pair<double, double> OptionalAxis::bounds() const
50	{	38	{
51	if (!m_Defined \|\| m_Data->size() == 0) {	39	if (!m_Defined \|\| m_Data->size() == 0) {
@@ -97,3 +85,23 bool OptionalAxis::operator!=(const OptionalAxis &other)
97	{	85	{
98	return !(*this == other);	86	return !(*this == other);
99	}	87	}
		88
		89	ArrayDataIterator OptionalAxis::begin()
		90	{
		91	return m_Data->begin();
		92	}
		93
		94	ArrayDataIterator OptionalAxis::end()
		95	{
		96	return m_Data->end();
		97	}
		98
		99	ArrayDataIterator OptionalAxis::cbegin() const
		100	{
		101	return m_Data->cbegin();
		102	}
		103
		104	ArrayDataIterator OptionalAxis::cend() const
		105	{
		106	return m_Data->cend();
		107	}

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

             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}
             {
             }

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)

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>
                 }
             }
-            #endif // SCIQLOP_DATASERIESUTILS_H
+            #endif // SCIQLOP_DATASERIESTESTSUTILS_H

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

@@ -17,10 +17,6 private slots:
17	void testDefinedAxisCtor_data();	17	void testDefinedAxisCtor_data();
18	void testDefinedAxisCtor();	18	void testDefinedAxisCtor();
19		19
20	/// Tests @sa OptionalAxis::at() method
21	void testAt_data();
22	void testAt();
23
24	/// Tests @sa OptionalAxis::size() method	20	/// Tests @sa OptionalAxis::size() method
25	void testSize_data();	21	void testSize_data();
26	void testSize();	22	void testSize();
@@ -64,39 +60,6 void TestOptionalAxis::testDefinedAxisCtor()
64	}	60	}
65	}	61	}
66		62
67	void TestOptionalAxis::testAt_data()
68	{
69	QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not)
70	QTest::addColumn<int>("index"); // Index to test in the axis
71	QTest::addColumn<double>("expectedValue"); // Expected axis value for the index
72
73	OptionalAxis definedAxis{std::make_shared<ArrayData<1> >(std::vector<double>{1, 2, 3}),
74	Unit{"Hz"}};
75
76	QTest::newRow("data1") << definedAxis << 0 << 1.;
77	QTest::newRow("data2") << definedAxis << 1 << 2.;
78	QTest::newRow("data3") << definedAxis << 2 << 3.;
79	QTest::newRow("data4 (index out of bounds)")
80	<< definedAxis << 3
81	<< std::numeric_limits<double>::quiet_NaN(); // Expects NaN for out of bounds index
82	QTest::newRow("data5 (index out of bounds)")
83	<< definedAxis << -1
84	<< std::numeric_limits<double>::quiet_NaN(); // Expects NaN for out of bounds index
85	QTest::newRow("data6 (axis not defined)")
86	<< OptionalAxis{} << 0
87	<< std::numeric_limits<double>::quiet_NaN(); // Expects NaN for undefined axis
88	}
89
90	void TestOptionalAxis::testAt()
91	{
92	QFETCH(OptionalAxis, axis);
93	QFETCH(int, index);
94	QFETCH(double, expectedValue);
95
96	auto value = axis.at(index);
97	QVERIFY((std::isnan(value) && std::isnan(expectedValue)) \|\| value == expectedValue);
98	}
99
100	void TestOptionalAxis::testSize_data()	63	void TestOptionalAxis::testSize_data()
101	{	64	{
102	QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not)	65	QTest::addColumn<OptionalAxis>("axis"); // Axis used for test case (defined or not)

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

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

             #include "Data/SpectrogramSeries.h"
             #include "DataSeriesBuilders.h"
-            #include "DataSeriesUtils.h"
+            #include "DataSeriesTestsUtils.h"
             #include <QObject>
             #include <QtTest>
             /**
              * @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

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

core/tests/meson.build +3 -2

               [['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'],
             amdatest_sources = [
               'Data/DataSeriesBuilders.h',
               'Data/DataSeriesBuilders.cpp',
-              'Data/DataSeriesUtils.h',
+              'Data/DataSeriesTestsUtils.h',
-              'Data/DataSeriesUtils.cpp'
+              'Data/DataSeriesTestsUtils.cpp'
             ]
             foreach unit_test : tests

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

                 {
                     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();
                     // 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});
                 }
             };

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

@@ -1,6 +1,7
1	#include "Visualization/VisualizationGraphHelper.h"	1	#include "Visualization/VisualizationGraphHelper.h"
2	#include "Visualization/qcustomplot.h"	2	#include "Visualization/qcustomplot.h"
3		3
		4	#include <Data/DataSeriesUtils.h>
4	#include <Data/ScalarSeries.h>	5	#include <Data/ScalarSeries.h>
5	#include <Data/SpectrogramSeries.h>	6	#include <Data/SpectrogramSeries.h>
6	#include <Data/VectorSeries.h>	7	#include <Data/VectorSeries.h>
@@ -180,8 +181,7 struct PlottablesUpdater<T,
180	static void setPlotYAxisRange(T &dataSeries, const SqpRange &xAxisRange, QCustomPlot &plot)	181	static void setPlotYAxisRange(T &dataSeries, const SqpRange &xAxisRange, QCustomPlot &plot)
181	{	182	{
182	double min, max;	183	double min, max;
183	/// @todo ALX: use iterators here	184	std::tie(min, max) = dataSeries.yBounds();
184	std::tie(min, max) = dataSeries.yAxis().bounds();
185		185
186	if (!std::isnan(min) && !std::isnan(max)) {	186	if (!std::isnan(min) && !std::isnan(max)) {
187	plot.yAxis->setRange(QCPRange{min, max});	187	plot.yAxis->setRange(QCPRange{min, max});
@@ -204,43 +204,42 struct PlottablesUpdater<T,
204		204
205	dataSeries.lockRead();	205	dataSeries.lockRead();
206		206
		207	// Processing spectrogram data for display in QCustomPlot
207	auto its = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);	208	auto its = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);
208	/// @todo ALX: use iterators here
209	auto yAxis = dataSeries.yAxis();
210
211	// Gets properties of x-axis and y-axis to set size and range of the colormap
212	auto nbX = std::distance(its.first, its.second);
213	auto xMin = nbX != 0 ? its.first->x() : 0.;
214	auto xMax = nbX != 0 ? (its.second - 1)->x() : 0.;
215
216	auto nbY = yAxis.size();
217	auto yMin = 0., yMax = 0.;
218	if (nbY != 0) {
219	std::tie(yMin, yMax) = yAxis.bounds();
220	}
221		209
222	colormap->data()->setSize(nbX, nbY);	210	// Computes logarithmic y-axis resolution for the spectrogram
223	colormap->data()->setRange(QCPRange{xMin, xMax}, QCPRange{yMin, yMax});	211	auto yData = its.first->y();
		212	auto yResolution = DataSeriesUtils::resolution(yData.begin(), yData.end(), true);
		213
		214	// Generates mesh for colormap
		215	auto mesh = DataSeriesUtils::regularMesh(
		216	its.first, its.second, DataSeriesUtils::Resolution{dataSeries.xResolution()},
		217	yResolution);
		218
		219	dataSeries.unlock();
224		220
225	// Sets values	221	colormap->data()->setSize(mesh.m_NbX, mesh.m_NbY);
226	auto xIndex = 0;	222	if (!mesh.isEmpty()) {
227	for (auto it = its.first; it != its.second; ++it, ++xIndex) {	223	colormap->data()->setRange(
228	for (auto yIndex = 0; yIndex < nbY; ++yIndex) {	224	QCPRange{mesh.m_XMin, mesh.xMax()},
229	auto value = it->value(yIndex);	225	// y-axis range is converted to linear values
		226	QCPRange{std::pow(10, mesh.m_YMin), std::pow(10, mesh.yMax())});
230		227
231	colormap->data()->setCell(xIndex, yIndex, value);	228	// Sets values
		229	auto index = 0;
		230	for (auto it = mesh.m_Data.begin(), end = mesh.m_Data.end(); it != end; ++it, ++index) {
		231	auto xIndex = index % mesh.m_NbX;
		232	auto yIndex = index / mesh.m_NbX;
232		233
233	// Processing spectrogram data for display in QCustomPlot	234	colormap->data()->setCell(xIndex, yIndex, *it);
234	/// For the moment, we just make the NaN values to be transparent in the colormap	235
235	/// @todo ALX: complete treatments (mesh generation, etc.)	236	// Makes the NaN values to be transparent in the colormap
236	if (std::isnan(~~value~~)) {	237	if (std::isnan(*it)) {
237	colormap->data()->setAlpha(xIndex, yIndex, 0);	238	colormap->data()->setAlpha(xIndex, yIndex, 0);
238	}	239	}
239	}	240	}
240	}	241	}
241		242
242	dataSeries.unlock();
243
244	// Rescales axes	243	// Rescales axes
245	auto plot = colormap->parentPlot();	244	auto plot = colormap->parentPlot();
246		245

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

             /// 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;
             /// ... - 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 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;

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

                 void readResultLine(const QString &line) override;
             private:
+                void handleDataHoles();
                 Properties m_Properties{};
                 std::vector<double> m_XAxisData{};
                 std::vector<double> m_YAxisData{};

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_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*(.*)")};

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

             #include <Common/DateUtils.h>
             #include <Common/SortUtils.h>
+            #include <Data/DataSeriesUtils.h>
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/Unit.h>
             }
             /**
+             * 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()
              */
                 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;
                 // 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)
                     [&] {
                         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) {
                 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 //
             // ////////////////// //

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

@@ -135,11 +135,10 struct ExpectedResults {
135	QCOMPARE(yAxis.unit(), m_YAxisUnit);	135	QCOMPARE(yAxis.unit(), m_YAxisUnit);
136		136
137	// Data	137	// Data
138	auto yAxisSize = yAxis.size();	138	QVERIFY(std::equal(yAxis.cbegin(), yAxis.cend(), m_YAxisData.cbegin(),
139	QCOMPARE(yAxisSize, m_YAxisData.size());	139	m_YAxisData.cend(), [](const auto &it, const auto &expectedVal) {
140	for (auto i = 0; i < yAxisSize; ++i) {	140	return it.first() == expectedVal;
141	QCOMPARE(yAxis.at(i), m_YAxisData.at(i));	141	}));
142	}
143	}	142	}
144	}	143	}
145	else {	144	else {
@@ -397,6 +396,135 void TestAmdaResultParser::testReadSpectrogramTxt_data()
397	<< QStringLiteral("spectro/ValidSpectrogramFillValues.txt")	396	<< QStringLiteral("spectro/ValidSpectrogramFillValues.txt")
398	<< nanValuesResult; // Fill values are replaced by NaN values in the data series	397	<< nanValuesResult; // Fill values are replaced by NaN values in the data series
399		398
		399	QTest::newRow("Valid file (containing data holes, resolution = 3 minutes)")
		400	<< QStringLiteral("spectro/ValidSpectrogramDataHoles.txt")
		401	<< ExpectedResults<SpectrogramSeries>{}
		402	.setParsingOK(true)
		403	.setXAxisUnit(Unit{"t", true})
		404	.setXAxisData({dateTime(2011, 12, 10, 12, 10, 54), //
		405	dateTime(2011, 12, 10, 12, 13, 54), // Data hole
		406	dateTime(2011, 12, 10, 12, 16, 54), // Data hole
		407	dateTime(2011, 12, 10, 12, 17, 23), //
		408	dateTime(2011, 12, 10, 12, 20, 23), // Data hole
		409	dateTime(2011, 12, 10, 12, 23, 23), // Data hole
		410	dateTime(2011, 12, 10, 12, 23, 51), //
		411	dateTime(2011, 12, 10, 12, 26, 51), // Data hole
		412	dateTime(2011, 12, 10, 12, 29, 51), // Data hole
		413	dateTime(2011, 12, 10, 12, 30, 19), //
		414	dateTime(2011, 12, 10, 12, 33, 19), // Data hole
		415	dateTime(2011, 12, 10, 12, 35, 04), //
		416	dateTime(2011, 12, 10, 12, 36, 41), //
		417	dateTime(2011, 12, 10, 12, 38, 18), //
		418	dateTime(2011, 12, 10, 12, 39, 55)})
		419	.setYAxisEnabled(true)
		420	.setYAxisUnit(Unit{"eV"})
		421	.setYAxisData({16485.85, 20996.1}) // middle of the intervals of each band
		422	.setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
		423	.setValuesData(QVector<QVector<double> >{{2577578.000, //
		424	nan, // Data hole
		425	nan, // Data hole
		426	2314121.500, //
		427	nan, // Data hole
		428	nan, // Data hole
		429	2063608.750, //
		430	nan, // Data hole
		431	nan, // Data hole
		432	2234525.500, //
		433	nan, // Data hole
		434	1670215.250, //
		435	1689243.250, //
		436	1654617.125, //
		437	1504983.750},
		438	{2336016.000, //
		439	nan, // Data hole
		440	nan, // Data hole
		441	1712093.125, //
		442	nan, // Data hole
		443	nan, // Data hole
		444	1614491.625, //
		445	nan, // Data hole
		446	nan, // Data hole
		447	1764516.500, //
		448	nan, // Data hole
		449	1688078.500, //
		450	1743183.500, //
		451	1733603.250, //
		452	1708356.500}});
		453
		454	QTest::newRow(
		455	"Valid file (containing data holes at the beginning and the end, resolution = 4 minutes)")
		456	<< QStringLiteral("spectro/ValidSpectrogramDataHoles2.txt")
		457	<< ExpectedResults<SpectrogramSeries>{}
		458	.setParsingOK(true)
		459	.setXAxisUnit(Unit{"t", true})
		460	.setXAxisData({
		461	dateTime(2011, 12, 10, 12, 2, 54), // Data hole
		462	dateTime(2011, 12, 10, 12, 6, 54), // Data hole
		463	dateTime(2011, 12, 10, 12, 10, 54), //
		464	dateTime(2011, 12, 10, 12, 14, 54), // Data hole
		465	dateTime(2011, 12, 10, 12, 17, 23), //
		466	dateTime(2011, 12, 10, 12, 21, 23), // Data hole
		467	dateTime(2011, 12, 10, 12, 23, 51), //
		468	dateTime(2011, 12, 10, 12, 27, 51), // Data hole
		469	dateTime(2011, 12, 10, 12, 30, 19), //
		470	dateTime(2011, 12, 10, 12, 34, 19), // Data hole
		471	dateTime(2011, 12, 10, 12, 35, 04), //
		472	dateTime(2011, 12, 10, 12, 36, 41), //
		473	dateTime(2011, 12, 10, 12, 38, 18), //
		474	dateTime(2011, 12, 10, 12, 39, 55),
		475	dateTime(2011, 12, 10, 12, 43, 55), // Data hole
		476	dateTime(2011, 12, 10, 12, 47, 55), // Data hole
		477	dateTime(2011, 12, 10, 12, 51, 55), // Data hole
		478	dateTime(2011, 12, 10, 12, 55, 55), // Data hole
		479	dateTime(2011, 12, 10, 12, 59, 55) // Data hole
		480	})
		481	.setYAxisEnabled(true)
		482	.setYAxisUnit(Unit{"eV"})
		483	.setYAxisData({16485.85, 20996.1}) // middle of the intervals of each band
		484	.setValuesUnit(Unit{"eV/(cm^2-s-sr-eV)"})
		485	.setValuesData(QVector<QVector<double> >{{
		486	nan, // Data hole
		487	nan, // Data hole
		488	2577578.000, //
		489	nan, // Data hole
		490	2314121.500, //
		491	nan, // Data hole
		492	2063608.750, //
		493	nan, // Data hole
		494	2234525.500, //
		495	nan, // Data hole
		496	1670215.250, //
		497	1689243.250, //
		498	1654617.125, //
		499	1504983.750, //
		500	nan, // Data hole
		501	nan, // Data hole
		502	nan, // Data hole
		503	nan, // Data hole
		504	nan // Data hole
		505	},
		506	{
		507	nan, // Data hole
		508	nan, // Data hole
		509	2336016.000, //
		510	nan, // Data hole
		511	1712093.125, //
		512	nan, // Data hole
		513	1614491.625, //
		514	nan, // Data hole
		515	1764516.500, //
		516	nan, // Data hole
		517	1688078.500, //
		518	1743183.500, //
		519	1733603.250, //
		520	1708356.500, //
		521	nan, // Data hole
		522	nan, // Data hole
		523	nan, // Data hole
		524	nan, // Data hole
		525	nan // Data hole
		526	}});
		527
400	// Invalid files	528	// Invalid files
401	QTest::newRow("Invalid file (inconsistent bands)")	529	QTest::newRow("Invalid file (inconsistent bands)")
402	<< QStringLiteral("spectro/InvalidSpectrogramWrongBands.txt")	530	<< QStringLiteral("spectro/InvalidSpectrogramWrongBands.txt")

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