HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r926:7347d93117b4

Merge pull request from SciQLop-fork develop...

trabillard -

r926:7347d93117b4

parent child

Context file:

r926:7347d93117b4

gui/include/Visualization/AxisRenderingUtils.h created 644 +34 0

@@ -0,0 +1,34
	1	#ifndef SCIQLOP_AXISRENDERINGUTILS_H
	2	#define SCIQLOP_AXISRENDERINGUTILS_H
	3
	4	#include <memory>
	5
	6	#include <QtCore/QString>
	7
	8	class IDataSeries;
	9	class QCPAxis;
	10	class QCPColorScale;
	11	class QCustomPlot;
	12
	13	/// Formats a data value according to the axis on which it is present
	14	QString formatValue(double value, const QCPAxis &axis);
	15
	16	/**
	17	* Helper used to handle axes rendering
	18	*/
	19	struct IAxisHelper {
	20	virtual ~IAxisHelper() noexcept = default;
	21
	22	/// Set properties of the plot's axes and the color scale associated to plot passed as
	23	/// parameters
	24	/// @param plot the plot for which to set axe properties
	25	/// @param colorScale the color scale for which to set properties
	26	virtual void setProperties(QCustomPlot &plot, QCPColorScale &colorScale) = 0;
	27	};
	28
	29	struct IAxisHelperFactory {
	30	/// Creates IAxisHelper according to a data series
	31	static std::unique_ptr<IAxisHelper> create(std::shared_ptr<IDataSeries> dataSeries) noexcept;
	32	};
	33
	34	#endif // SCIQLOP_AXISRENDERINGUTILS_H

gui/include/Visualization/PlottablesRenderingUtils.h created 644 +29 0

@@ -0,0 +1,29
	1	#ifndef SCIQLOP_PLOTTABLESRENDERINGUTILS_H
	2	#define SCIQLOP_PLOTTABLESRENDERINGUTILS_H
	3
	4	#include <Visualization/VisualizationDefs.h>
	5
	6	#include <memory>
	7
	8	class IDataSeries;
	9	class QCPColorScale;
	10	class QCustomPlot;
	11
	12	/**
	13	* Helper used to handle plottables rendering
	14	*/
	15	struct IPlottablesHelper {
	16	virtual ~IPlottablesHelper() noexcept = default;
	17
	18	/// Set properties of the plottables passed as parameter
	19	/// @param plottables the plottables for which to set properties
	20	virtual void setProperties(PlottablesMap &plottables) = 0;
	21	};
	22
	23	struct IPlottablesHelperFactory {
	24	/// Creates IPlottablesHelper according to a data series
	25	static std::unique_ptr<IPlottablesHelper>
	26	create(std::shared_ptr<IDataSeries> dataSeries) noexcept;
	27	};
	28
	29	#endif // SCIQLOP_PLOTTABLESRENDERINGUTILS_H

gui/src/Visualization/AxisRenderingUtils.cpp created 644 +163 0

@@ -0,0 +1,163
	1	#include "Visualization/AxisRenderingUtils.h"
	2
	3	#include <Data/ScalarSeries.h>
	4	#include <Data/SpectrogramSeries.h>
	5	#include <Data/VectorSeries.h>
	6
	7	#include <Visualization/qcustomplot.h>
	8
	9	namespace {
	10
	11	const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");
	12
	13	/// Format for datetimes on a axis
	14	const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
	15
	16	/// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
	17	/// non-time data
	18	QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
	19	{
	20	if (isTimeAxis) {
	21	auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
	22	dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
	23	dateTicker->setDateTimeSpec(Qt::UTC);
	24
	25	return dateTicker;
	26	}
	27	else {
	28	// default ticker
	29	return QSharedPointer<QCPAxisTicker>::create();
	30	}
	31	}
	32
	33	/**
	34	* Sets properties of the axis passed as parameter
	35	* @param axis the axis to set
	36	* @param unit the unit to set for the axis
	37	* @param scaleType the scale type to set for the axis
	38	*/
	39	void setAxisProperties(QCPAxis &axis, const Unit &unit,
	40	QCPAxis::ScaleType scaleType = QCPAxis::stLinear)
	41	{
	42	// label (unit name)
	43	axis.setLabel(unit.m_Name);
	44
	45	// scale type
	46	axis.setScaleType(scaleType);
	47
	48	// ticker (depending on the type of unit)
	49	axis.setTicker(axisTicker(unit.m_TimeUnit));
	50	}
	51
	52	/**
	53	* Delegate used to set axes properties
	54	*/
	55	template <typename T, typename Enabled = void>
	56	struct AxisSetter {
	57	static void setProperties(T &, QCustomPlot &, QCPColorScale &)
	58	{
	59	// Default implementation does nothing
	60	}
	61	};
	62
	63	/**
	64	* Specialization of AxisSetter for scalars and vectors
	65	* @sa ScalarSeries
	66	* @sa VectorSeries
	67	*/
	68	template <typename T>
	69	struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
	70	or std::is_base_of<VectorSeries, T>::value> > {
	71	static void setProperties(T &dataSeries, QCustomPlot &plot, QCPColorScale &)
	72	{
	73	dataSeries.lockRead();
	74	auto xAxisUnit = dataSeries.xAxisUnit();
	75	auto valuesUnit = dataSeries.valuesUnit();
	76	dataSeries.unlock();
	77
	78	setAxisProperties(*plot.xAxis, xAxisUnit);
	79	setAxisProperties(*plot.yAxis, valuesUnit);
	80	}
	81	};
	82
	83	/**
	84	* Specialization of AxisSetter for spectrograms
	85	* @sa SpectrogramSeries
	86	*/
	87	template <typename T>
	88	struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
	89	static void setProperties(T &dataSeries, QCustomPlot &plot, QCPColorScale &colorScale)
	90	{
	91	dataSeries.lockRead();
	92	auto xAxisUnit = dataSeries.xAxisUnit();
	93	/// @todo ALX: use iterators here
	94	auto yAxisUnit = dataSeries.yAxis().unit();
	95	auto valuesUnit = dataSeries.valuesUnit();
	96	dataSeries.unlock();
	97
	98	setAxisProperties(*plot.xAxis, xAxisUnit);
	99	setAxisProperties(*plot.yAxis, yAxisUnit);
	100
	101	// Displays color scale in plot
	102	plot.plotLayout()->insertRow(0);
	103	plot.plotLayout()->addElement(0, 0, &colorScale);
	104	colorScale.setType(QCPAxis::atTop);
	105	colorScale.setMinimumMargins(QMargins{0, 0, 0, 0});
	106
	107	// Aligns color scale with axes
	108	auto marginGroups = plot.axisRect()->marginGroups();
	109	for (auto it = marginGroups.begin(), end = marginGroups.end(); it != end; ++it) {
	110	colorScale.setMarginGroup(it.key(), it.value());
	111	}
	112
	113	// Set color scale properties
	114	colorScale.setLabel(valuesUnit.m_Name);
	115	colorScale.setDataScaleType(QCPAxis::stLogarithmic); // Logarithmic scale
	116	}
	117	};
	118
	119	/**
	120	* Default implementation of IAxisHelper, which takes data series to set axes properties
	121	* @tparam T the data series' type
	122	*/
	123	template <typename T>
	124	struct AxisHelper : public IAxisHelper {
	125	explicit AxisHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
	126
	127	void setProperties(QCustomPlot &plot, QCPColorScale &colorScale) override
	128	{
	129	AxisSetter<T>::setProperties(m_DataSeries, plot, colorScale);
	130	}
	131
	132	T &m_DataSeries;
	133	};
	134
	135	} // namespace
	136
	137	QString formatValue(double value, const QCPAxis &axis)
	138	{
	139	// If the axis is a time axis, formats the value as a date
	140	if (auto axisTicker = qSharedPointerDynamicCast<QCPAxisTickerDateTime>(axis.ticker())) {
	141	return DateUtils::dateTime(value, axisTicker->dateTimeSpec()).toString(DATETIME_FORMAT);
	142	}
	143	else {
	144	return QString::number(value);
	145	}
	146	}
	147
	148	std::unique_ptr<IAxisHelper>
	149	IAxisHelperFactory::create(std::shared_ptr<IDataSeries> dataSeries) noexcept
	150	{
	151	if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
	152	return std::make_unique<AxisHelper<ScalarSeries> >(*scalarSeries);
	153	}
	154	else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
	155	return std::make_unique<AxisHelper<SpectrogramSeries> >(*spectrogramSeries);
	156	}
	157	else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
	158	return std::make_unique<AxisHelper<VectorSeries> >(*vectorSeries);
	159	}
	160	else {
	161	return std::make_unique<AxisHelper<IDataSeries> >(*dataSeries);
	162	}
	163	}

gui/src/Visualization/PlottablesRenderingUtils.cpp created 644 +120 0

@@ -0,0 +1,120
	1	#include "Visualization/PlottablesRenderingUtils.h"
	2
	3	#include <Common/ColorUtils.h>
	4
	5	#include <Data/ScalarSeries.h>
	6	#include <Data/SpectrogramSeries.h>
	7	#include <Data/VectorSeries.h>
	8
	9	#include <Visualization/qcustomplot.h>
	10
	11	namespace {
	12
	13	/// Default gradient used for colormap
	14	const auto DEFAULT_COLORMAP_GRADIENT = QCPColorGradient::gpJet;
	15
	16	/**
	17	* Delegate used to set plottables properties
	18	*/
	19	template <typename T, typename Enabled = void>
	20	struct PlottablesSetter {
	21	static void setProperties(T &, PlottablesMap &)
	22	{
	23	// Default implementation does nothing
	24	}
	25	};
	26
	27	/**
	28	* Specialization of PlottablesSetter for scalars and vectors
	29	* @sa ScalarSeries
	30	* @sa VectorSeries
	31	*/
	32	template <typename T>
	33	struct PlottablesSetter<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
	34	or std::is_base_of<VectorSeries, T>::value> > {
	35	static void setProperties(T &dataSeries, PlottablesMap &plottables)
	36	{
	37	// Gets the number of components of the data series
	38	dataSeries.lockRead();
	39	auto componentCount = dataSeries.valuesData()->componentCount();
	40	dataSeries.unlock();
	41
	42	// Generates colors for each component
	43	auto colors = ColorUtils::colors(Qt::blue, Qt::red, componentCount);
	44
	45	// For each component of the data series, creates a QCPGraph to add to the plot
	46	for (auto i = 0; i < componentCount; ++i) {
	47	auto graph = plottables.at(i);
	48	graph->setPen(QPen{colors.at(i)});
	49	}
	50	}
	51	};
	52
	53	/**
	54	* Specialization of PlottablesSetter for spectrograms
	55	* @sa SpectrogramSeries
	56	*/
	57	template <typename T>
	58	struct PlottablesSetter<T,
	59	typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
	60	static void setProperties(T &, PlottablesMap &plottables)
	61	{
	62	// Checks that for a spectrogram there is only one plottable, that is a colormap
	63	if (plottables.size() != 1) {
	64	return;
	65	}
	66
	67	if (auto colormap = dynamic_cast<QCPColorMap *>(plottables.begin()->second)) {
	68	colormap->setInterpolate(false); // No value interpolation
	69	colormap->setTightBoundary(true);
	70
	71	// Finds color scale in the colormap's plot to associate with it
	72	auto plot = colormap->parentPlot();
	73	auto plotElements = plot->plotLayout()->elements(false);
	74	for (auto plotElement : plotElements) {
	75	if (auto colorScale = dynamic_cast<QCPColorScale *>(plotElement)) {
	76	colormap->setColorScale(colorScale);
	77	}
	78	}
	79
	80	// Sets gradient used for color scale
	81	colormap->setGradient(DEFAULT_COLORMAP_GRADIENT);
	82	colormap->rescaleDataRange();
	83	}
	84	}
	85	};
	86
	87	/**
	88	* Default implementation of IPlottablesHelper, which takes data series to set plottables properties
	89	* @tparam T the data series' type
	90	*/
	91	template <typename T>
	92	struct PlottablesHelper : public IPlottablesHelper {
	93	explicit PlottablesHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
	94
	95	void setProperties(PlottablesMap &plottables) override
	96	{
	97	PlottablesSetter<T>::setProperties(m_DataSeries, plottables);
	98	}
	99
	100	T &m_DataSeries;
	101	};
	102
	103	} // namespace
	104
	105	std::unique_ptr<IPlottablesHelper>
	106	IPlottablesHelperFactory::create(std::shared_ptr<IDataSeries> dataSeries) noexcept
	107	{
	108	if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
	109	return std::make_unique<PlottablesHelper<ScalarSeries> >(*scalarSeries);
	110	}
	111	else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
	112	return std::make_unique<PlottablesHelper<SpectrogramSeries> >(*spectrogramSeries);
	113	}
	114	else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
	115	return std::make_unique<PlottablesHelper<VectorSeries> >(*vectorSeries);
	116	}
	117	else {
	118	return std::make_unique<PlottablesHelper<IDataSeries> >(*dataSeries);
	119	}
	120	}

core/src/Data/OptionalAxis.cpp +2 0

             #include <Data/OptionalAxis.h>
             #include "Data/ArrayData.h"
             OptionalAxis::OptionalAxis() : m_Defined{false}, m_Data{nullptr}, 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_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());
                         });
                     auto pair = std::make_pair(minIt->first(), maxIt->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);
             }

gui/include/Visualization/VisualizationGraphRenderingDelegate.h +10 -2

             #ifndef SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H
             #define SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H
             #include <Common/spimpl.h>
+            #include <Visualization/VisualizationDefs.h>
+            class IDataSeries;
             class QCustomPlot;
             class QMouseEvent;
             class Unit;
             class VisualizationGraphWidget;
             class VisualizationGraphRenderingDelegate {
             public:
                 /// Ctor
                 /// @param graphWidget the graph widget to which the delegate is associated
                 /// @remarks the graph widget must exist throughout the life cycle of the delegate
                 explicit VisualizationGraphRenderingDelegate(VisualizationGraphWidget &graphWidget);
                 void onMouseMove(QMouseEvent *event) noexcept;
-                /// Sets properties of the plot's axes
+                /// Sets properties of the plot's axes from the data series passed as parameter
-                void setAxesProperties(const Unit &xAxisUnit, const Unit &valuesUnit) noexcept;
+                void setAxesProperties(std::shared_ptr<IDataSeries> dataSeries) noexcept;
+                /// Sets rendering properties of the plottables passed as parameter, from the data series that
+                /// generated these
+                void setPlottablesProperties(std::shared_ptr<IDataSeries> dataSeries,
+                                             PlottablesMap &plottables) noexcept;
                 /// Shows or hides graph overlay (name, close button, etc.)
                 void showGraphOverlay(bool show) noexcept;
             private:
                 class VisualizationGraphRenderingDelegatePrivate;
                 spimpl::unique_impl_ptr<VisualizationGraphRenderingDelegatePrivate> impl;
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H

gui/meson.build +2 0

             gui_moc_headers = [
               'include/DataSource/DataSourceWidget.h',
               'include/DataSource/DataSourceTreeWidget.h',
               'include/Settings/SqpSettingsDialog.h',
               'include/Settings/SqpSettingsGeneralWidget.h',
               'include/SidePane/SqpSidePane.h',
               'include/SqpApplication.h',
               'include/DragAndDrop/DragDropHelper.h',
               'include/DragAndDrop/DragDropScroller.h',
               'include/DragAndDrop/DragDropTabSwitcher.h',
               'include/TimeWidget/TimeWidget.h',
               'include/Variable/VariableInspectorWidget.h',
               'include/Variable/VariableInspectorTableView.h',
               'include/Variable/RenameVariableDialog.h',
               'include/Visualization/qcustomplot.h',
               'include/Visualization/VisualizationGraphWidget.h',
               'include/Visualization/VisualizationTabWidget.h',
               'include/Visualization/VisualizationWidget.h',
               'include/Visualization/VisualizationZoneWidget.h',
               'include/Visualization/VisualizationDragDropContainer.h',
               'include/Visualization/VisualizationDragWidget.h'
             ]
             gui_ui_files = [
               'ui/DataSource/DataSourceWidget.ui',
               'ui/Settings/SqpSettingsDialog.ui',
               'ui/Settings/SqpSettingsGeneralWidget.ui',
               'ui/SidePane/SqpSidePane.ui',
               'ui/TimeWidget/TimeWidget.ui',
               'ui/Variable/VariableInspectorWidget.ui',
               'ui/Variable/RenameVariableDialog.ui',
               'ui/Variable/VariableMenuHeaderWidget.ui',
               'ui/Visualization/VisualizationGraphWidget.ui',
               'ui/Visualization/VisualizationTabWidget.ui',
               'ui/Visualization/VisualizationWidget.ui',
               'ui/Visualization/VisualizationZoneWidget.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files,
                                            qresources : gui_qresources)
             gui_sources = [
               'src/SqpApplication.cpp',
               'src/DragAndDrop/DragDropHelper.cpp',
               'src/DragAndDrop/DragDropScroller.cpp',
               'src/DragAndDrop/DragDropTabSwitcher.cpp',
               'src/Common/ColorUtils.cpp',
               'src/Common/VisualizationDef.cpp',
               'src/DataSource/DataSourceTreeWidgetItem.cpp',
               'src/DataSource/DataSourceTreeWidgetHelper.cpp',
               'src/DataSource/DataSourceWidget.cpp',
               'src/DataSource/DataSourceTreeWidget.cpp',
               'src/Settings/SqpSettingsDialog.cpp',
               'src/Settings/SqpSettingsGeneralWidget.cpp',
               'src/SidePane/SqpSidePane.cpp',
               'src/TimeWidget/TimeWidget.cpp',
               'src/Variable/VariableInspectorWidget.cpp',
               'src/Variable/VariableInspectorTableView.cpp',
               'src/Variable/VariableMenuHeaderWidget.cpp',
               'src/Variable/RenameVariableDialog.cpp',
               'src/Visualization/VisualizationGraphHelper.cpp',
               'src/Visualization/VisualizationGraphRenderingDelegate.cpp',
               'src/Visualization/VisualizationGraphWidget.cpp',
               'src/Visualization/VisualizationTabWidget.cpp',
               'src/Visualization/VisualizationWidget.cpp',
               'src/Visualization/VisualizationZoneWidget.cpp',
               'src/Visualization/qcustomplot.cpp',
               'src/Visualization/QCustomPlotSynchronizer.cpp',
               'src/Visualization/operations/FindVariableOperation.cpp',
               'src/Visualization/operations/GenerateVariableMenuOperation.cpp',
               'src/Visualization/operations/MenuBuilder.cpp',
               'src/Visualization/operations/RemoveVariableOperation.cpp',
               'src/Visualization/operations/RescaleAxeOperation.cpp',
               'src/Visualization/VisualizationDragDropContainer.cpp',
               'src/Visualization/VisualizationDragWidget.cpp'
+              'src/Visualization/AxisRenderingUtils.cpp',
+              'src/Visualization/PlottablesRenderingUtils.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core])

gui/src/Visualization/VisualizationGraphHelper.cpp +10 -7

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
-            #include <Common/ColorUtils.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();
-                    auto colors = ColorUtils::colors(Qt::blue, Qt::red, componentCount);
                     // 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();
-                        graph->setPen(QPen{colors.at(i)});
                         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.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();
                     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);
                     colormap->data()->setRange(QCPRange{xMin, xMax}, QCPRange{yMin, yMax});
                     // Sets values
                     auto xIndex = 0;
                     for (auto it = its.first; it != its.second; ++it, ++xIndex) {
                         for (auto yIndex = 0; yIndex < nbY; ++yIndex) {
-                            colormap->data()->setCell(xIndex, yIndex, it->value(yIndex));
+                            auto value = it->value(yIndex);
+                            colormap->data()->setCell(xIndex, yIndex, value);
+                            // Processing spectrogram data for display in QCustomPlot
+                            /// For the moment, we just make the NaN values to be transparent in the colormap
+                            /// @todo ALX: complete treatments (mesh generation, etc.)
+                            if (std::isnan(value)) {
+                                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);
             }

gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp +17 -47

             #include "Visualization/VisualizationGraphRenderingDelegate.h"
+            #include "Visualization/AxisRenderingUtils.h"
+            #include "Visualization/PlottablesRenderingUtils.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/qcustomplot.h"
             #include <Common/DateUtils.h>
             #include <Data/IDataSeries.h>
             #include <SqpApplication.h>
             namespace {
             /// Name of the axes layer in QCustomPlot
             const auto AXES_LAYER = QStringLiteral("axes");
-            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");
             /// Icon used to show x-axis properties
             const auto HIDE_AXIS_ICON_PATH = QStringLiteral(":/icones/down.png");
             /// Name of the overlay layer in QCustomPlot
             const auto OVERLAY_LAYER = QStringLiteral("overlay");
             /// Pixmap used to show x-axis properties
             const auto SHOW_AXIS_ICON_PATH = QStringLiteral(":/icones/up.png");
             const auto TOOLTIP_FORMAT = QStringLiteral("key: %1\nvalue: %2");
             /// Offset used to shift the tooltip of the mouse
             const auto TOOLTIP_OFFSET = QPoint{20, 20};
             /// Tooltip display rectangle (the tooltip is hidden when the mouse leaves this rectangle)
             const auto TOOLTIP_RECT = QRect{10, 10, 10, 10};
             /// Timeout after which the tooltip is displayed
             const auto TOOLTIP_TIMEOUT = 500;
-            /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
-            /// non-time data
-            QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
-                if (isTimeAxis) {
-                    auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
-                    dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
-                    dateTicker->setDateTimeSpec(Qt::UTC);
-                    return dateTicker;
-                else {
-                    // default ticker
-                    return QSharedPointer<QCPAxisTicker>::create();
-            /// Formats a data value according to the axis on which it is present
-            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);
             void initPointTracerStyle(QCPItemTracer &tracer) noexcept
             {
                 tracer.setInterpolating(false);
                 tracer.setStyle(QCPItemTracer::tsCircle);
                 tracer.setSize(3);
                 tracer.setPen(QPen(Qt::black));
                 tracer.setBrush(Qt::black);
             }
             QPixmap pixmap(const QString &iconPath) noexcept
             {
                 return QIcon{iconPath}.pixmap(QSize{16, 16});
             }
             void initClosePixmapStyle(QCPItemPixmap &pixmap) noexcept
             {
                 // Icon
                 pixmap.setPixmap(
                     sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton).pixmap(QSize{16, 16}));
                 // Position
                 pixmap.topLeft->setType(QCPItemPosition::ptAxisRectRatio);
                 pixmap.topLeft->setCoords(1, 0);
                 pixmap.setClipToAxisRect(false);
                 // Can be selected
                 pixmap.setSelectable(true);
             }
             void initXAxisPixmapStyle(QCPItemPixmap &itemPixmap) noexcept
             {
                 // Icon
                 itemPixmap.setPixmap(pixmap(HIDE_AXIS_ICON_PATH));
                 // Position
                 itemPixmap.topLeft->setType(QCPItemPosition::ptAxisRectRatio);
                 itemPixmap.topLeft->setCoords(0, 1);
                 itemPixmap.setClipToAxisRect(false);
                 // Can be selected
                 itemPixmap.setSelectable(true);
             }
             void initTitleTextStyle(QCPItemText &text) noexcept
             {
                 // Font and background styles
                 text.setColor(Qt::gray);
                 text.setBrush(Qt::white);
                 // Position
                 text.setPositionAlignment(Qt::AlignTop | Qt::AlignLeft);
                 text.position->setType(QCPItemPosition::ptAxisRectRatio);
                 text.position->setCoords(0.5, 0);
             }
             } // namespace
             struct VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegatePrivate {
                 explicit VisualizationGraphRenderingDelegatePrivate(VisualizationGraphWidget &graphWidget)
                         : m_Plot{graphWidget.plot()},
                           m_PointTracer{new QCPItemTracer{&m_Plot}},
                           m_TracerTimer{},
                           m_ClosePixmap{new QCPItemPixmap{&m_Plot}},
                           m_TitleText{new QCPItemText{&m_Plot}},
                           m_XAxisPixmap{new QCPItemPixmap{&m_Plot}},
                           m_ShowXAxis{true},
-                          m_XAxisLabel{}
+                          m_XAxisLabel{},
+                          m_ColorScale{new QCPColorScale{&m_Plot}}
                 {
                     initPointTracerStyle(*m_PointTracer);
                     m_TracerTimer.setInterval(TOOLTIP_TIMEOUT);
                     m_TracerTimer.setSingleShot(true);
                     // Inits "close button" in plot overlay
                     m_ClosePixmap->setLayer(OVERLAY_LAYER);
                     initClosePixmapStyle(*m_ClosePixmap);
                     // Connects pixmap selection to graph widget closing
                     QObject::connect(m_ClosePixmap, &QCPItemPixmap::selectionChanged,
                                      [&graphWidget](bool selected) {
                                          if (selected) {
                                              graphWidget.close();
                                          }
                                      });
                     // Inits graph name in plot overlay
                     m_TitleText->setLayer(OVERLAY_LAYER);
                     m_TitleText->setText(graphWidget.name());
                     initTitleTextStyle(*m_TitleText);
                     // Inits "show x-axis button" in plot overlay
                     m_XAxisPixmap->setLayer(OVERLAY_LAYER);
                     initXAxisPixmapStyle(*m_XAxisPixmap);
                     // Connects pixmap selection to graph x-axis showing/hiding
                     QObject::connect(m_XAxisPixmap, &QCPItemPixmap::selectionChanged, [this]() {
                         if (m_XAxisPixmap->selected()) {
                             // Changes the selection state and refreshes the x-axis
                             m_ShowXAxis = !m_ShowXAxis;
                             updateXAxisState();
                             m_Plot.layer(AXES_LAYER)->replot();
                             // Deselects the x-axis pixmap and updates icon
                             m_XAxisPixmap->setSelected(false);
                             m_XAxisPixmap->setPixmap(
                                 pixmap(m_ShowXAxis ? HIDE_AXIS_ICON_PATH : SHOW_AXIS_ICON_PATH));
                             m_Plot.layer(OVERLAY_LAYER)->replot();
                         }
                     });
                 }
                 /// Updates state of x-axis according to the current selection of x-axis pixmap
                 /// @remarks the method doesn't call plot refresh
                 void updateXAxisState() noexcept
                 {
                     m_Plot.xAxis->setTickLabels(m_ShowXAxis);
                     m_Plot.xAxis->setLabel(m_ShowXAxis ? m_XAxisLabel : QString{});
                 }
                 QCustomPlot &m_Plot;
                 QCPItemTracer *m_PointTracer;
                 QTimer m_TracerTimer;
                 QCPItemPixmap *m_ClosePixmap; /// Graph's close button
                 QCPItemText *m_TitleText;     /// Graph's title
                 QCPItemPixmap *m_XAxisPixmap;
                 bool m_ShowXAxis; /// X-axis properties are shown or hidden
                 QString m_XAxisLabel;
+                QCPColorScale *m_ColorScale; /// Color scale used for some types of graphs (as spectrograms)
             };
             VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegate(
                 VisualizationGraphWidget &graphWidget)
                     : impl{spimpl::make_unique_impl<VisualizationGraphRenderingDelegatePrivate>(graphWidget)}
             {
             }
             void VisualizationGraphRenderingDelegate::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Cancels pending refresh
                 impl->m_TracerTimer.disconnect();
                 // Reinits tracers
                 impl->m_PointTracer->setGraph(nullptr);
                 impl->m_PointTracer->setVisible(false);
                 impl->m_Plot.replot();
                 // Gets the graph under the mouse position
                 auto eventPos = event->pos();
                 if (auto graph = qobject_cast<QCPGraph *>(impl->m_Plot.plottableAt(eventPos))) {
                     auto mouseKey = graph->keyAxis()->pixelToCoord(eventPos.x());
                     auto graphData = graph->data();
                     // Gets the closest data point to the mouse
                     auto graphDataIt = graphData->findBegin(mouseKey);
                     if (graphDataIt != graphData->constEnd()) {
                         auto key = formatValue(graphDataIt->key, *graph->keyAxis());
                         auto value = formatValue(graphDataIt->value, *graph->valueAxis());
                         // Displays point tracer
                         impl->m_PointTracer->setGraph(graph);
                         impl->m_PointTracer->setGraphKey(graphDataIt->key);
                         impl->m_PointTracer->setLayer(
                             impl->m_Plot.layer("main")); // Tracer is set on top of the plot's main layer
                         impl->m_PointTracer->setVisible(true);
                         impl->m_Plot.replot();
                         // Starts timer to show tooltip after timeout
                         auto showTooltip = [ tooltip = TOOLTIP_FORMAT.arg(key, value), eventPos, this ]()
                         {
                             QToolTip::showText(impl->m_Plot.mapToGlobal(eventPos) + TOOLTIP_OFFSET, tooltip,
                                                &impl->m_Plot, TOOLTIP_RECT);
                         };
                         QObject::connect(&impl->m_TracerTimer, &QTimer::timeout, showTooltip);
                         impl->m_TracerTimer.start();
                     }
                 }
             }
-            void VisualizationGraphRenderingDelegate::setAxesProperties(const Unit &xAxisUnit,
+            void VisualizationGraphRenderingDelegate::setAxesProperties(
-                                                                        const Unit &valuesUnit) noexcept
+                std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 // Stores x-axis label to be able to retrieve it when x-axis pixmap is unselected
-                impl->m_XAxisLabel = xAxisUnit.m_Name;
+                impl->m_XAxisLabel = dataSeries->xAxisUnit().m_Name;
-                auto setAxisProperties = [](auto axis, const auto &unit) {
+                auto axisHelper = IAxisHelperFactory::create(dataSeries);
-                    // label (unit name)
+                axisHelper->setProperties(impl->m_Plot, *impl->m_ColorScale);
-                    axis->setLabel(unit.m_Name);
-                    // ticker (depending on the type of unit)
-                    axis->setTicker(axisTicker(unit.m_TimeUnit));
-                };
-                setAxisProperties(impl->m_Plot.xAxis, xAxisUnit);
-                setAxisProperties(impl->m_Plot.yAxis, valuesUnit);
                 // Updates x-axis state
                 impl->updateXAxisState();
                 impl->m_Plot.layer(AXES_LAYER)->replot();
             }
+            void VisualizationGraphRenderingDelegate::setPlottablesProperties(
+                std::shared_ptr<IDataSeries> dataSeries, PlottablesMap &plottables) noexcept
+            {
+                auto plottablesHelper = IPlottablesHelperFactory::create(dataSeries);
+                plottablesHelper->setProperties(plottables);
+            }
             void VisualizationGraphRenderingDelegate::showGraphOverlay(bool show) noexcept
             {
                 auto overlay = impl->m_Plot.layer(OVERLAY_LAYER);
                 overlay->setVisible(show);
                 overlay->replot();
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +9 -12

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationDefs.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Common/MimeTypesDef.h>
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <DragAndDrop/DragDropHelper.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 explicit VisualizationGraphWidgetPrivate(const QString &name)
                         : m_Name{name},
                           m_DoAcquisition{true},
                           m_IsCalibration{false},
                           m_RenderingDelegate{nullptr}
                 {
                 }
                 QString m_Name;
                 // 1 variable -> n qcpplot
                 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
                 bool m_DoAcquisition;
                 bool m_IsCalibration;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectItems);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 // The delegate must be initialized after the ui as it uses the plot
                 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*this);
                 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
                 connect(ui->widget, &QCustomPlot::mouseRelease, this,
                         &VisualizationGraphWidget::onMouseRelease);
                 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
                                                &QCPAxis::rangeChanged),
                         this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
                 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
                         &VariableController::onRequestDataLoading);
                 connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this,
                         &VisualizationGraphWidget::onUpdateVarDisplaying);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             VisualizationZoneWidget *VisualizationGraphWidget::parentZoneWidget() const noexcept
             {
                 auto parent = parentWidget();
                 while (parent != nullptr && !qobject_cast<VisualizationZoneWidget *>(parent)) {
                     parent = parent->parentWidget();
                 }
                 return qobject_cast<VisualizationZoneWidget *>(parent);
             }
             void VisualizationGraphWidget::enableAcquisition(bool enable)
             {
                 impl->m_DoAcquisition = enable;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
-                impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
-                // Set axes properties according to the units of the data series
-                /// @todo : for the moment, no control is performed on the axes: the units and the tickers
-                /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
-                auto xAxisUnit = Unit{};
-                auto valuesUnit = Unit{};
                 if (auto dataSeries = variable->dataSeries()) {
-                    dataSeries->lockRead();
+                    // Set axes properties according to the units of the data series
-                    xAxisUnit = dataSeries->xAxisUnit();
+                    impl->m_RenderingDelegate->setAxesProperties(dataSeries);
-                    valuesUnit = dataSeries->valuesUnit();
-                    dataSeries->unlock();
+                    // Sets rendering properties for the new plottables
+                    // Warning: this method must be called after setAxesProperties(), as it can access to some
+                    // axes properties that have to be initialized
+                    impl->m_RenderingDelegate->setPlottablesProperties(dataSeries, createdPlottables);
                 }
-                impl->m_RenderingDelegate->setAxesProperties(xAxisUnit, valuesUnit);
+                impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
                 this->enableAcquisition(false);
                 this->setGraphRange(range);
                 this->enableAcquisition(true);
                 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, false);
                 emit variableAdded(variable);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
                 auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);
                 if (variableIt != impl->m_VariableToPlotMultiMap.cend()) {
                     emit variableAboutToBeRemoved(variable);
                     auto &plottablesMap = variableIt->second;
                     for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
                          plottableIt != plottableEnd;) {
                         ui->widget->removePlottable(plottableIt->second);
                         plottableIt = plottablesMap.erase(plottableIt);
                     }
                     impl->m_VariableToPlotMultiMap.erase(variableIt);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             QList<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
             {
                 auto variables = QList<std::shared_ptr<Variable> >{};
                 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
                      it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
                     variables << it->first;
                 }
                 return variables;
             }
             void VisualizationGraphWidget::setYRange(std::shared_ptr<Variable> variable)
             {
                 if (!variable) {
                     qCCritical(LOG_VisualizationGraphWidget()) << "Can't set y-axis range: variable is null";
                     return;
                 }
                 VisualizationGraphHelper::setYAxisRange(variable, *ui->widget);
             }
             SqpRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto graphRange = ui->widget->xAxis->range();
                 return SqpRange{graphRange.lower, graphRange.upper};
             }
             void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visit(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationGraphWidget::canDrop(const Variable &variable) const
             {
                 /// @todo : for the moment, a graph can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationGraphWidget::contains(const Variable &variable) const
             {
                 // Finds the variable among the keys of the map
                 auto variablePtr = &variable;
                 auto findVariable
                     = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
                 auto end = impl->m_VariableToPlotMultiMap.cend();
                 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
                 return it != end;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return impl->m_Name;
             }
             QMimeData *VisualizationGraphWidget::mimeData() const
             {
                 auto mimeData = new QMimeData;
                 mimeData->setData(MIME_TYPE_GRAPH, QByteArray{});
                 auto timeRangeData = TimeController::mimeDataForTimeRange(graphRange());
                 mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 return mimeData;
             }
             bool VisualizationGraphWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationGraphWidget::highlightForMerge(bool highlighted)
             {
                 if (highlighted) {
                     plot().setBackground(QBrush(QColor("#BBD5EE")));
                 }
                 else {
                     plot().setBackground(QBrush(Qt::white));
                 }
                 plot().update();
             }
             void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
             {
                 Q_UNUSED(event);
                 // Prevents that all variables will be removed from graph when it will be closed
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
                     emit variableAboutToBeRemoved(variableEntry.first);
                 }
             }
             void VisualizationGraphWidget::enterEvent(QEvent *event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(true);
             }
             void VisualizationGraphWidget::leaveEvent(QEvent *event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(false);
             }
             QCustomPlot &VisualizationGraphWidget::plot() noexcept
             {
                 return *ui->widget;
             }
             void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
             {
                 QMenu graphMenu{};
                 // Iterates on variables (unique keys)
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
                           end = impl->m_VariableToPlotMultiMap.cend();
                      it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                     // 'Remove variable' action
                     graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
                                         [ this, var = it->first ]() { removeVariable(var); });
                 }
                 if (!graphMenu.isEmpty()) {
                     graphMenu.exec(QCursor::pos());
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
                                                         << QThread::currentThread()->objectName() << "DoAcqui"
                                                         << impl->m_DoAcquisition;
                 auto graphRange = SqpRange{t1.lower, t1.upper};
                 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
                 if (impl->m_DoAcquisition) {
                     QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
                     for (auto it = impl->m_VariableToPlotMultiMap.begin(),
                               end = impl->m_VariableToPlotMultiMap.end();
                          it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                         variableUnderGraphVector.push_back(it->first);
                     }
                     emit requestDataLoading(std::move(variableUnderGraphVector), graphRange,
                                             !impl->m_IsCalibration);
                     if (!impl->m_IsCalibration) {
                         qCDebug(LOG_VisualizationGraphWidget())
                             << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
                             << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
                         emit synchronize(graphRange, oldGraphRange);
                     }
                 }
             }
             void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->onMouseMove(event);
                 VisualizationDragWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
                 // Lambda that enables a zoom orientation if the key modifier related to this orientation
                 // has
                 // been pressed
                 auto enableOrientation
                     = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                           auto orientationEnabled = event->modifiers().testFlag(modifier);
                           zoomOrientations.setFlag(orientation, orientationEnabled);
                       };
                 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
                 plot().setInteraction(QCP::iRangeDrag, !event->modifiers().testFlag(Qt::AltModifier));
                 VisualizationDragWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = false;
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 auto graphRange = ui->widget->xAxis->range();
                 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
                     auto variable = variableEntry.first;
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
                     if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
                         VisualizationGraphHelper::updateData(variableEntry.second, variable->dataSeries(),
                                                              variable->range());
                     }
                 }
             }
             void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
                                                                  const SqpRange &range)
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end()) {
                     VisualizationGraphHelper::updateData(it->second, variable->dataSeries(), range);
                 }
             }

plugins/mockplugin/src/CosinusProvider.cpp +38 -21

             #include "CosinusProvider.h"
             #include "MockDefs.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <cmath>
+            #include <set>
             #include <QFuture>
             #include <QThread>
             #include <QtConcurrent/QtConcurrent>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
             namespace {
             /// Number of bands generated for a spectrogram
             const auto SPECTROGRAM_NUMBER_BANDS = 30;
+            /// Bands for which to generate NaN values for a spectrogram
+            const auto SPECTROGRAM_NAN_BANDS = std::set<int>{1, 3, 10, 20};
+            /// Bands for which to generate zeros for a spectrogram
+            const auto SPECTROGRAM_ZERO_BANDS = std::set<int>{2, 15, 19, 29};
             /// Abstract cosinus type
             struct ICosinusType {
                 virtual ~ICosinusType() = default;
                 /// @return the number of components generated for the type
                 virtual int componentCount() const = 0;
                 /// @return the data series created for the type
                 virtual std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
-                                                                      std::vector<double> valuesData,
+                                                                      std::vector<double> valuesData) const = 0;
-                                                                      Unit xAxisUnit,
-                                                                      Unit valuesUnit) const = 0;
                 /// Generates values (one value per component)
                 /// @param x the x-axis data used to generate values
                 /// @param values the vector in which to insert the generated values
                 /// @param dataIndex the index of insertion of the generated values
                 ///
                 virtual void generateValues(double x, std::vector<double> &values, int dataIndex) const = 0;
             };
             struct ScalarCosinus : public ICosinusType {
                 int componentCount() const override { return 1; }
                 std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
-                                                              std::vector<double> valuesData, Unit xAxisUnit,
+                                                              std::vector<double> valuesData) const override
-                                                              Unit valuesUnit) const override
                 {
                     return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
-                                                          xAxisUnit, valuesUnit);
+                                                          Unit{QStringLiteral("t"), true}, Unit{});
                 }
                 void generateValues(double x, std::vector<double> &values, int dataIndex) const override
                 {
                     values[dataIndex] = std::cos(x);
                 }
             };
             struct SpectrogramCosinus : public ICosinusType {
                 /// Ctor with y-axis
-                explicit SpectrogramCosinus(std::vector<double> yAxisData, Unit yAxisUnit)
+                explicit SpectrogramCosinus(std::vector<double> yAxisData, Unit yAxisUnit, Unit valuesUnit)
-                        : m_YAxisData{std::move(yAxisData)}, m_YAxisUnit{std::move(yAxisUnit)}
+                        : m_YAxisData{std::move(yAxisData)},
+                          m_YAxisUnit{std::move(yAxisUnit)},
+                          m_ValuesUnit{std::move(valuesUnit)}
                 {
                 }
                 int componentCount() const override { return m_YAxisData.size(); }
                 std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
-                                                              std::vector<double> valuesData, Unit xAxisUnit,
+                                                              std::vector<double> valuesData) const override
-                                                              Unit valuesUnit) const override
                 {
-                    return std::make_shared<SpectrogramSeries>(std::move(xAxisData), m_YAxisData,
+                    return std::make_shared<SpectrogramSeries>(
-                                                               std::move(valuesData), xAxisUnit, m_YAxisUnit,
+                        std::move(xAxisData), m_YAxisData, std::move(valuesData),
-                                                               valuesUnit);
+                        Unit{QStringLiteral("t"), true}, m_YAxisUnit, m_ValuesUnit);
                 }
                 void generateValues(double x, std::vector<double> &values, int dataIndex) const override
                 {
                     auto componentCount = this->componentCount();
                     for (int i = 0; i < componentCount; ++i) {
                         auto y = m_YAxisData[i];
-                        auto r = 3 * std::sqrt(x * x + y * y) + 1e-2;
-                        auto value = 2 * x * (std::cos(r + 2) / r - std::sin(r + 2) / r);
+                        double value;
+                        if (SPECTROGRAM_ZERO_BANDS.find(y) != SPECTROGRAM_ZERO_BANDS.end()) {
+                            value = 0.;
+                        }
+                        else if (SPECTROGRAM_NAN_BANDS.find(y) != SPECTROGRAM_NAN_BANDS.end()) {
+                            value = std::numeric_limits<double>::quiet_NaN();
+                        }
+                        else {
+                            // Generates value for non NaN/zero bands
+                            auto r = 3 * std::sqrt(x * x + y * y) + 1e-2;
+                            value = 2 * x * (std::cos(r + 2) / r - std::sin(r + 2) / r);
+                        }
                         values[componentCount * dataIndex + i] = value;
                     }
                 }
                 std::vector<double> m_YAxisData;
                 Unit m_YAxisUnit;
+                Unit m_ValuesUnit;
             };
             struct VectorCosinus : public ICosinusType {
                 int componentCount() const override { return 3; }
                 std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
-                                                              std::vector<double> valuesData, Unit xAxisUnit,
+                                                              std::vector<double> valuesData) const override
-                                                              Unit valuesUnit) const override
                 {
                     return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(valuesData),
-                                                          xAxisUnit, valuesUnit);
+                                                          Unit{QStringLiteral("t"), true}, Unit{});
                 }
                 void generateValues(double x, std::vector<double> &values, int dataIndex) const override
                 {
                     // Generates value for each component: cos(x), cos(x)/2, cos(x)/3
                     auto xValue = std::cos(x);
                     auto componentCount = this->componentCount();
                     for (auto i = 0; i < componentCount; ++i) {
                         values[componentCount * dataIndex + i] = xValue / (i + 1);
                     }
                 }
             };
             /// Converts string to cosinus type
             /// @return the cosinus type if the string could be converted, nullptr otherwise
             std::unique_ptr<ICosinusType> cosinusType(const QString &type) noexcept
             {
                 if (type.compare(QStringLiteral("scalar"), Qt::CaseInsensitive) == 0) {
                     return std::make_unique<ScalarCosinus>();
                 }
                 else if (type.compare(QStringLiteral("spectrogram"), Qt::CaseInsensitive) == 0) {
                     // Generates default y-axis data for spectrogram [0., 1., 2., ...]
                     std::vector<double> yAxisData(SPECTROGRAM_NUMBER_BANDS);
                     std::iota(yAxisData.begin(), yAxisData.end(), 0.);
-                    return std::make_unique<SpectrogramCosinus>(std::move(yAxisData), Unit{"eV"});
+                    return std::make_unique<SpectrogramCosinus>(std::move(yAxisData), Unit{"eV"},
+                                                                Unit{"eV/(cm^2-s-sr-eV)"});
                 }
                 else if (type.compare(QStringLiteral("vector"), Qt::CaseInsensitive) == 0) {
                     return std::make_unique<VectorCosinus>();
                 }
                 else {
                     return nullptr;
                 }
             }
             } // namespace
             std::shared_ptr<IDataProvider> CosinusProvider::clone() const
             {
                 // No copy is made in clone
                 return std::make_shared<CosinusProvider>();
             }
             std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
                                                                        const SqpRange &dataRangeRequested,
                                                                        const QVariantHash &data)
             {
                 // TODO: Add Mutex
                 auto dataIndex = 0;
                 // Retrieves cosinus type
                 auto typeVariant = data.value(COSINUS_TYPE_KEY, COSINUS_TYPE_DEFAULT_VALUE);
                 if (!typeVariant.canConvert<QString>()) {
                     qCCritical(LOG_CosinusProvider()) << tr("Can't retrieve data: invalid type");
                     return nullptr;
                 }
                 auto type = cosinusType(typeVariant.toString());
                 if (!type) {
                     qCCritical(LOG_CosinusProvider()) << tr("Can't retrieve data: unknown type");
                     return nullptr;
                 }
                 // Retrieves frequency
                 auto freqVariant = data.value(COSINUS_FREQUENCY_KEY, COSINUS_FREQUENCY_DEFAULT_VALUE);
                 if (!freqVariant.canConvert<double>()) {
                     qCCritical(LOG_CosinusProvider()) << tr("Can't retrieve data: invalid frequency");
                     return nullptr;
                 }
                 // Gets the timerange from the parameters
                 double freq = freqVariant.toDouble();
                 double start = std::ceil(dataRangeRequested.m_TStart * freq);
                 double end = std::floor(dataRangeRequested.m_TEnd * freq);
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second, end value is
                 // included)
                 auto dataCount = end - start + 1;
                 // Number of components (depending on the cosinus type)
                 auto componentCount = type->componentCount();
                 auto xAxisData = std::vector<double>{};
                 xAxisData.resize(dataCount);
                 auto valuesData = std::vector<double>{};
                 valuesData.resize(dataCount * componentCount);
                 int progress = 0;
                 auto progressEnd = dataCount;
                 for (auto time = start; time <= end; ++time, ++dataIndex) {
                     auto it = m_VariableToEnableProvider.find(acqIdentifier);
                     if (it != m_VariableToEnableProvider.end() && it.value()) {
                         const auto x = time / freq;
                         xAxisData[dataIndex] = x;
                         // Generates values (depending on the type)
                         type->generateValues(x, valuesData, dataIndex);
                         // progression
                         int currentProgress = (time - start) * 100.0 / progressEnd;
                         if (currentProgress != progress) {
                             progress = currentProgress;
                             emit dataProvidedProgress(acqIdentifier, progress);
                             qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::retrieveData"
                                                            << QThread::currentThread()->objectName()
                                                            << progress;
                             // NOTE: Try to use multithread if possible
                         }
                     }
                     else {
                         if (!it.value()) {
                             qCDebug(LOG_CosinusProvider())
                                 << "CosinusProvider::retrieveData: ARRET De l'acquisition detecté"
                                 << end - time;
                         }
                     }
                 }
                 if (progress != 100) {
                     // We can close progression beacause all data has been retrieved
                     emit dataProvidedProgress(acqIdentifier, 100);
                 }
-                return type->createDataSeries(std::move(xAxisData), std::move(valuesData),
+                return type->createDataSeries(std::move(xAxisData), std::move(valuesData));
-                                              Unit{QStringLiteral("t"), true}, Unit{});
             }
             void CosinusProvider::requestDataLoading(QUuid acqIdentifier,
                                                      const DataProviderParameters &parameters)
             {
                 // TODO: Add Mutex
                 m_VariableToEnableProvider[acqIdentifier] = true;
                 qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::requestDataLoading"
                                                << QThread::currentThread()->objectName();
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 for (const auto &dateTime : qAsConst(times)) {
                     if (m_VariableToEnableProvider[acqIdentifier]) {
                         auto scalarSeries = this->retrieveData(acqIdentifier, dateTime, parameters.m_Data);
                         emit dataProvided(acqIdentifier, scalarSeries, dateTime);
                     }
                 }
             }
             void CosinusProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << acqIdentifier
                                                << QThread::currentThread()->objectName();
                 auto it = m_VariableToEnableProvider.find(acqIdentifier);
                 if (it != m_VariableToEnableProvider.end()) {
                     it.value() = false;
                 }
                 else {
                     qCDebug(LOG_CosinusProvider())
                         << tr("Aborting progression of inexistant identifier detected !!!");
                 }
             }
             std::shared_ptr<IDataSeries> CosinusProvider::provideDataSeries(const SqpRange &dataRangeRequested,
                                                                             const QVariantHash &data)
             {
                 auto uid = QUuid::createUuid();
                 m_VariableToEnableProvider[uid] = true;
                 auto dataSeries = this->retrieveData(uid, dataRangeRequested, data);
                 m_VariableToEnableProvider.remove(uid);
                 return dataSeries;
             }

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