GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r495:f81e8612a847

Merge pull request from SCIQLOP-Initialisation develop...

perrinel -

r495:f81e8612a847

parent child

Context file:

r495:f81e8612a847

core/include/Common/DateUtils.h created 644 +19 0

@@ -0,0 +1,19
	1	#ifndef SCIQLOP_DATEUTILS_H
	2	#define SCIQLOP_DATEUTILS_H
	3
	4	#include "CoreGlobal.h"
	5
	6	#include <QDateTime>
	7
	8	/**
	9	* Utility class with methods for dates
	10	*/
	11	struct SCIQLOP_CORE_EXPORT DateUtils {
	12	/// Converts seconds (since epoch) to datetime. By default, the datetime is in UTC
	13	static QDateTime dateTime(double secs, Qt::TimeSpec timeSpec = Qt::UTC) noexcept;
	14
	15	/// Converts datetime to seconds since epoch
	16	static double secondsSinceEpoch(const QDateTime &dateTime) noexcept;
	17	};
	18
	19	#endif // SCIQLOP_DATEUTILS_H

core/src/Common/DateUtils.cpp created 644 +13 0

@@ -0,0 +1,13
	1	#include "Common/DateUtils.h"
	2
	3	QDateTime DateUtils::dateTime(double secs, Qt::TimeSpec timeSpec) noexcept
	4	{
	5	// Uses msecs to be Qt 4 compatible
	6	return QDateTime::fromMSecsSinceEpoch(secs * 1000., timeSpec);
	7	}
	8
	9	double DateUtils::secondsSinceEpoch(const QDateTime &dateTime) noexcept
	10	{
	11	// Uses msecs to be Qt 4 compatible
	12	return dateTime.toMSecsSinceEpoch() / 1000.;
	13	}

gui/include/Visualization/VisualizationGraphRenderingDelegate.h created 644 +20 0

@@ -0,0 +1,20
	1	#ifndef SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H
	2	#define SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H
	3
	4	#include <Common/spimpl.h>
	5
	6	class QCustomPlot;
	7	class QMouseEvent;
	8
	9	class VisualizationGraphRenderingDelegate {
	10	public:
	11	explicit VisualizationGraphRenderingDelegate(QCustomPlot &plot);
	12
	13	void onMouseMove(QMouseEvent *event) noexcept;
	14
	15	private:
	16	class VisualizationGraphRenderingDelegatePrivate;
	17	spimpl::unique_impl_ptr<VisualizationGraphRenderingDelegatePrivate> impl;
	18	};
	19
	20	#endif // SCIQLOP_VISUALIZATIONGRAPHRENDERINGDELEGATE_H

gui/src/Visualization/VisualizationGraphRenderingDelegate.cpp created 644 +123 0

@@ -0,0 +1,123
	1	#include "Visualization/VisualizationGraphRenderingDelegate.h"
	2	#include "Visualization/qcustomplot.h"
	3
	4	#include <Common/DateUtils.h>
	5
	6	namespace {
	7
	8	const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");
	9
	10	const auto TEXT_TRACER_FORMAT = QStringLiteral("key: %1\nvalue: %2");
	11
	12	/// Timeout after which a tracer is displayed
	13	const auto TRACER_TIMEOUT = 500;
	14
	15	/// Formats a data value according to the axis on which it is present
	16	QString formatValue(double value, const QCPAxis &axis)
	17	{
	18	// If the axis is a time axis, formats the value as a date
	19	if (auto axisTicker = qSharedPointerDynamicCast<QCPAxisTickerDateTime>(axis.ticker())) {
	20	return DateUtils::dateTime(value, axisTicker->dateTimeSpec()).toString(DATETIME_FORMAT);
	21	}
	22	else {
	23	return QString::number(value);
	24	}
	25	}
	26
	27	void initPointTracerStyle(QCPItemTracer &tracer) noexcept
	28	{
	29	tracer.setInterpolating(false);
	30	tracer.setStyle(QCPItemTracer::tsPlus);
	31	tracer.setPen(QPen(Qt::black));
	32	tracer.setBrush(Qt::black);
	33	tracer.setSize(10);
	34	}
	35
	36	void initTextTracerStyle(QCPItemText &tracer) noexcept
	37	{
	38	tracer.setPen(QPen{Qt::gray});
	39	tracer.setBrush(Qt::white);
	40	tracer.setPadding(QMargins{6, 6, 6, 6});
	41	tracer.setPositionAlignment(Qt::AlignTop \| Qt::AlignLeft);
	42	tracer.setTextAlignment(Qt::AlignLeft);
	43	}
	44
	45	} // namespace
	46
	47	struct VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegatePrivate {
	48	explicit VisualizationGraphRenderingDelegatePrivate(QCustomPlot &plot)
	49	: m_Plot{plot},
	50	m_PointTracer{new QCPItemTracer{&plot}},
	51	m_TextTracer{new QCPItemText{&plot}},
	52	m_TracerTimer{}
	53	{
	54	initPointTracerStyle(*m_PointTracer);
	55	initTextTracerStyle(*m_TextTracer);
	56
	57	m_TracerTimer.setInterval(TRACER_TIMEOUT);
	58	m_TracerTimer.setSingleShot(true);
	59	}
	60
	61	QCustomPlot &m_Plot;
	62	QCPItemTracer *m_PointTracer;
	63	QCPItemText *m_TextTracer;
	64	QTimer m_TracerTimer;
	65	};
	66
	67	VisualizationGraphRenderingDelegate::VisualizationGraphRenderingDelegate(QCustomPlot &plot)
	68	: impl{spimpl::make_unique_impl<VisualizationGraphRenderingDelegatePrivate>(plot)}
	69	{
	70	}
	71
	72	void VisualizationGraphRenderingDelegate::onMouseMove(QMouseEvent *event) noexcept
	73	{
	74	// Cancels pending refresh
	75	impl->m_TracerTimer.disconnect();
	76
	77	auto showTracers = [ eventPos = event->pos(), this ]()
	78	{
	79	// Lambda function to display a tracer
	80	auto displayTracer = [this](auto &tracer) {
	81	// Tracer is set on top of the plot's main layer
	82	tracer.setLayer(impl->m_Plot.layer("main"));
	83	tracer.setVisible(true);
	84	impl->m_Plot.replot();
	85	};
	86
	87	// Reinits tracers
	88	impl->m_PointTracer->setGraph(nullptr);
	89	impl->m_PointTracer->setVisible(false);
	90	impl->m_TextTracer->setVisible(false);
	91	impl->m_Plot.replot();
	92
	93	// Gets the graph under the mouse position
	94	if (auto graph = qobject_cast<QCPGraph *>(impl->m_Plot.plottableAt(eventPos))) {
	95	auto mouseKey = graph->keyAxis()->pixelToCoord(eventPos.x());
	96	auto graphData = graph->data();
	97
	98	// Gets the closest data point to the mouse
	99	auto graphDataIt = graphData->findBegin(mouseKey);
	100	if (graphDataIt != graphData->constEnd()) {
	101	auto key = formatValue(graphDataIt->key, *graph->keyAxis());
	102	auto value = formatValue(graphDataIt->value, *graph->valueAxis());
	103	impl->m_TextTracer->setText(TEXT_TRACER_FORMAT.arg(key, value));
	104
	105	// Displays point tracer
	106	impl->m_PointTracer->setGraph(graph);
	107	impl->m_PointTracer->setGraphKey(graphDataIt->key);
	108	displayTracer(*impl->m_PointTracer);
	109
	110	// Displays text tracer
	111	auto tracerPosition = impl->m_TextTracer->position;
	112	tracerPosition->setAxes(graph->keyAxis(), graph->valueAxis());
	113	tracerPosition->setCoords(impl->m_PointTracer->position->key(),
	114	impl->m_PointTracer->position->value());
	115	displayTracer(*impl->m_TextTracer);
	116	}
	117	}
	118	};
	119
	120	// Starts the timer to display tracers at timeout
	121	QObject::connect(&impl->m_TracerTimer, &QTimer::timeout, showTracers);
	122	impl->m_TracerTimer.start();
	123	}

app/src/MainWindow.cpp 0 -1

             #include <QAction>
             #include <QDate>
-            #include <QDateTime>
             #include <QDir>
             #include <QFileDialog>
             #include <QToolBar>

core/include/Data/IDataSeries.h +1 -1

                 inline bool operator!=(const Unit &other) const { return !(*this == other); }
                 QString m_Name;  ///< Unit name
-                bool m_TimeUnit; ///< The unit is a unit of time
+                bool m_TimeUnit; ///< The unit is a unit of time (UTC)
             };
             /**

core/include/Data/SqpDateTime.h +5 -6

             #include <QObject>
-            #include <QDateTime>
             #include <QDebug>
+            #include <Common/DateUtils.h>
             #include <Common/MetaTypes.h>
             /**
              * @brief The SqpDateTime struct holds the information of time parameters
              */
             struct SqpDateTime {
-                /// Start time
+                /// Start time (UTC)
                 double m_TStart;
-                /// End time
+                /// End time (UTC)
                 double m_TEnd;
                 bool contains(const SqpDateTime &dateTime) const noexcept
             inline QDebug operator<<(QDebug d, SqpDateTime obj)
             {
-                auto tendDateTimeStart = QDateTime::fromMSecsSinceEpoch(obj.m_TStart * 1000);
+                auto tendDateTimeStart = DateUtils::dateTime(obj.m_TStart);
-                auto tendDateTimeEnd = QDateTime::fromMSecsSinceEpoch(obj.m_TEnd * 1000);
+                auto tendDateTimeEnd = DateUtils::dateTime(obj.m_TEnd);
-                //        QDebug << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
                 d << "ts: " << tendDateTimeStart << " te: " << tendDateTimeEnd;
                 return d;
             }

core/src/Variable/VariableController.cpp 0 -1

             #include <Data/IDataSeries.h>
             #include <Time/TimeController.h>
-            #include <QDateTime>
             #include <QMutex>
             #include <QThread>
             #include <QUuid>

core/src/Variable/VariableModel.cpp +4 -3

             #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
+            #include <Common/DateUtils.h>
             #include <Data/IDataSeries.h>
-            #include <QDateTime>
             #include <QSize>
             #include <unordered_map>
                 if (role == Qt::DisplayRole) {
                     if (auto variable = impl->m_Variables.at(index.row()).get()) {
                         /// Lambda function that builds the variant to return for a time value
-                        auto dateTimeVariant = [](double time) {
+                        auto dateTimeVariant = [](double secs) {
-                            auto dateTime = QDateTime::fromMSecsSinceEpoch(time * 1000.);
+                            auto dateTime = DateUtils::dateTime(secs);
                             return dateTime.toString(DATETIME_FORMAT);
                         };

gui/include/Visualization/VisualizationGraphWidget.h +2 0

                 /// Rescale the X axe to range parameter
                 void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
+                /// Slot called when a mouse move was made
+                void onMouseMove(QMouseEvent *event) noexcept;
                 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
                 void onMouseWheel(QWheelEvent *event) noexcept;
                 /// Slot called when a mouse press was made, to activate the calibration of a graph

gui/src/TimeWidget/TimeWidget.cpp +11 -9

             #include "TimeWidget/TimeWidget.h"
             #include "ui_TimeWidget.h"
+            #include <Common/DateUtils.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
                         &TimeController::onTimeNotify);
                 // Initialisation
-                ui->startDateTimeEdit->setDateTime(
+                auto endDateTime = QDateTime::currentDateTimeUtc();
-                    QDateTime::currentDateTime().addSecs(-3600)); // one hour berefore
+                auto startDateTime = endDateTime.addSecs(-3600); // one hour before
-                ui->endDateTimeEdit->setDateTime(QDateTime::currentDateTime());
+                ui->startDateTimeEdit->setDateTime(startDateTime);
+                ui->endDateTimeEdit->setDateTime(endDateTime);
+                auto dateTime = SqpDateTime{DateUtils::secondsSinceEpoch(startDateTime),
+                                            DateUtils::secondsSinceEpoch(endDateTime)};
-                auto dateTime
-                    = SqpDateTime{QDateTime::currentDateTime().addSecs(-3600).toMSecsSinceEpoch() / 1000.0,
-                                  QDateTime::currentDateTime().toMSecsSinceEpoch() / 1000.0};
                 sqpApp->timeController().onTimeToUpdate(dateTime);
             }
             void TimeWidget::onTimeUpdateRequested()
             {
-                auto dateTime = SqpDateTime{
+                auto dateTime = SqpDateTime{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
-                    static_cast<double>(ui->startDateTimeEdit->dateTime().toMSecsSinceEpoch() / 1000.),
+                                            DateUtils::secondsSinceEpoch(ui->endDateTimeEdit->dateTime())};
-                    static_cast<double>(ui->endDateTimeEdit->dateTime().toMSecsSinceEpoch()) / 1000.};
                 emit timeUpdated(std::move(dateTime));
             }

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

                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
+                    dateTicker->setDateTimeSpec(Qt::UTC);
                     return dateTicker;
                 }

gui/src/Visualization/VisualizationGraphWidget.cpp +19 -3

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphHelper.h"
+            #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Data/ArrayData.h>
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
-                explicit VisualizationGraphWidgetPrivate() : m_DoSynchronize{true}, m_IsCalibration{false} {}
+                explicit VisualizationGraphWidgetPrivate()
+                        : m_DoSynchronize{true}, m_IsCalibration{false}, m_RenderingDelegate{nullptr}
+                {
+                }
                 // Return the operation when range changed
                 VisualizationGraphWidgetZoomType getZoomType(const QCPRange &t1, const QCPRange &t2);
                 // 1 variable -> n qcpplot
                 std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
                 bool m_DoSynchronize;
                 bool m_IsCalibration;
+                QCPItemTracer *m_TextTracer;
+                /// Delegate used to attach rendering features to the plot
+                std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
             {
                 ui->setupUi(this);
+                // The delegate must be initialized after the ui as it uses the plot
+                impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*ui->widget);
                 ui->graphNameLabel->setText(name);
                 // 'Close' options : widget is deleted when closed
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 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),
                 }
             }
+            void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
+            {
+                // Handles plot rendering when mouse is moving
+                impl->m_RenderingDelegate->onMouseMove(event);
+            }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};

gui/ui/TimeWidget/TimeWidget.ui +6 0

                  <property name="calendarPopup">
                   <bool>true</bool>
                  </property>
+                 <property name="timeSpec">
+                  <enum>Qt::UTC</enum>
+                 </property>
                 </widget>
                </item>
                <item>
                  <property name="calendarPopup">
                   <bool>true</bool>
                  </property>
+                 <property name="timeSpec">
+                  <enum>Qt::UTC</enum>
+                 </property>
                 </widget>
                </item>
                <item>

plugins/amda/src/AmdaProvider.cpp +2 -1

             #include "AmdaDefs.h"
             #include "AmdaResultParser.h"
+            #include <Common/DateUtils.h>
             #include <Data/DataProviderParameters.h>
             #include <Network/NetworkController.h>
             #include <SqpApplication.h>
             /// Formats a time to a date that can be passed in URL
             QString dateFormat(double sqpDateTime) noexcept
             {
-                auto dateTime = QDateTime::fromMSecsSinceEpoch(sqpDateTime * 1000.);
+                auto dateTime = DateUtils::dateTime(sqpDateTime);
                 return dateTime.toString(AMDA_TIME_FORMAT);
             }

plugins/amda/src/AmdaResultParser.cpp +39 -32

             #include "AmdaResultParser.h"
+            #include <Common/DateUtils.h>
             #include <Data/ScalarSeries.h>
             #include <QDateTime>
             double doubleDate(const QString &stringDate) noexcept
             {
                 auto dateTime = QDateTime::fromString(stringDate, DATE_FORMAT);
-                return dateTime.isValid() ? (dateTime.toMSecsSinceEpoch() / 1000.)
+                dateTime.setTimeSpec(Qt::UTC);
+                return dateTime.isValid() ? DateUtils::secondsSinceEpoch(dateTime)
                                           : std::numeric_limits<double>::quiet_NaN();
             }
+            /// Checks if a line is a comment line
+            bool isCommentLine(const QString &line)
+            {
+                return line.startsWith("#");
+            }
             /**
              * Reads stream to retrieve x-axis unit
              * @param stream the stream to read
             {
                 QString line{};
-                if (stream.readLineInto(&line)) {
+                // Searches unit in the comment lines
+                while (stream.readLineInto(&line) && isCommentLine(line)) {
                     auto match = UNIT_REGEX.match(line);
                     if (match.hasMatch()) {
                         return Unit{match.captured(1), true};
                     }
-                    else {
-                        qCWarning(LOG_AmdaResultParser())
-                            << QObject::tr("Can't read unit: invalid line %1").arg(line);
-                else {
-                    qCWarning(LOG_AmdaResultParser()) << QObject::tr("Can't read unit: end of file");
                 }
+                qCWarning(LOG_AmdaResultParser()) << QObject::tr("The unit could not be found in the file");
                 // Error cases
                 return Unit{{}, true};
             }
                 auto valuesData = QVector<double>{};
                 QString line{};
                 while (stream.readLineInto(&line)) {
-                    auto lineData = line.split(RESULT_LINE_SEPARATOR, QString::SkipEmptyParts);
+                    // Ignore comment lines
-                    if (lineData.size() == 2) {
+                    if (!isCommentLine(line)) {
-                        // X : the data is converted from date to double (in secs)
+                        auto lineData = line.split(RESULT_LINE_SEPARATOR, QString::SkipEmptyParts);
-                        auto x = doubleDate(lineData.at(0));
+                        if (lineData.size() == 2) {
+                            // X : the data is converted from date to double (in secs)
-                        // Value
+                            auto x = doubleDate(lineData.at(0));
-                        bool valueOk;
-                        auto value = lineData.at(1).toDouble(&valueOk);
+                            // Value
+                            bool valueOk;
-                        // Adds result only if x and value are valid
+                            auto value = lineData.at(1).toDouble(&valueOk);
-                        if (!std::isnan(x) && !std::isnan(value) && valueOk) {
-                            xData.push_back(x);
+                            // Adds result only if x and value are valid
-                            valuesData.push_back(value);
+                            if (!std::isnan(x) && !std::isnan(value) && valueOk) {
+                                xData.push_back(x);
+                                valuesData.push_back(value);
+                            }
+                            else {
+                                qCWarning(LOG_AmdaResultParser())
+                                    << QObject::tr(
+                                           "Can't retrieve results from line %1: x and/or value are invalid")
+                                           .arg(line);
+                            }
                         }
                         else {
                             qCWarning(LOG_AmdaResultParser())
-                                << QObject::tr(
+                                << QObject::tr("Can't retrieve results from line %1: invalid line").arg(line);
-                                       "Can't retrieve results from line %1: x and/or value are invalid")
-                                       .arg(line);
                         }
                     }
-                    else {
-                        qCWarning(LOG_AmdaResultParser())
-                            << QObject::tr("Can't retrieve results from line %1: invalid line").arg(line);
                 }
                 return qMakePair(std::move(xData), std::move(valuesData));
                     return nullptr;
                 }
-                // Ignore comments lines
-                stream.readLine();
                 // Reads x-axis unit
+                stream.seek(0); // returns to the beginning of the file
                 auto xAxisUnit = readXAxisUnit(stream);
                 // Reads results
+                stream.seek(0); // returns to the beginning of the file
                 auto results = readResults(stream);
                 return std::make_shared<ScalarSeries>(std::move(results.first), std::move(results.second),

plugins/amda/tests/TestAmdaResultParser.cpp +1 -1

                 // ////////// //
                 auto dateTime = [](int year, int month, int day, int hours, int minutes, int seconds) {
-                    return QDateTime{{year, month, day}, {hours, minutes, seconds}};
+                    return QDateTime{{year, month, day}, {hours, minutes, seconds}, Qt::UTC};
                 };
                 // Valid file

plugins/mockplugin/src/CosinusProvider.cpp 0 -1

             #include <cmath>
-            #include <QDateTime>
             #include <QFuture>
             #include <QThread>
             #include <QtConcurrent/QtConcurrent>

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