GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r276:3a08c66e4df2

Fix the cosinus bug....

perrinel -

r276:3a08c66e4df2

parent child

Context file:

r276:3a08c66e4df2

core/include/Variable/Variable.h +1 -1

             #ifndef SCIQLOP_VARIABLE_H
             #define SCIQLOP_VARIABLE_H
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_Variable)
             class IDataSeries;
             class QString;
             /**
              * @brief The Variable class represents a variable in SciQlop.
              */
             class Variable : public QObject {
                 Q_OBJECT
             public:
                 explicit Variable(const QString &name, const QString &unit, const QString &mission,
                                   const SqpDateTime &dateTime);
                 QString name() const noexcept;
                 QString mission() const noexcept;
                 QString unit() const noexcept;
                 SqpDateTime dateTime() const noexcept;
                 void setDateTime(const SqpDateTime &dateTime) noexcept;
                 /// @return the data of the variable, nullptr if there is no data
                 IDataSeries *dataSeries() const noexcept;
                 bool contains(const SqpDateTime &dateTime);
                 bool intersect(const SqpDateTime &dateTime);
                 void setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept;
             public slots:
                 void onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             signals:
-                void dataCacheUpdated();
+                void updated();
             private:
                 class VariablePrivate;
                 spimpl::unique_impl_ptr<VariablePrivate> impl;
             };
             // Required for using shared_ptr in signals/slots
             Q_DECLARE_METATYPE(std::shared_ptr<Variable>)
             #endif // SCIQLOP_VARIABLE_H

core/include/Variable/VariableController.h +2 -3

             #ifndef SCIQLOP_VARIABLECONTROLLER_H
             #define SCIQLOP_VARIABLECONTROLLER_H
             #include <Data/SqpDateTime.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <Common/spimpl.h>
             class IDataProvider;
             class TimeController;
             class Variable;
             class VariableModel;
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableController)
             /**
              * @brief The VariableController class aims to handle the variables in SciQlop.
              */
             class VariableController : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableController(QObject *parent = 0);
                 virtual ~VariableController();
                 VariableModel *variableModel() noexcept;
                 void setTimeController(TimeController *timeController) noexcept;
-                /// Request the data loading of the variable whithin dateTime
-                void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
             signals:
                 /// Signal emitted when a variable has been created
                 void variableCreated(std::shared_ptr<Variable> variable);
             public slots:
+                /// Request the data loading of the variable whithin dateTime
+                void onRequestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
                 /**
                  * Creates a new variable and adds it to the model
                  * @param name the name of the new variable
                  * @param provider the data provider for the new variable
                  */
                 void createVariable(const QString &name, std::shared_ptr<IDataProvider> provider) noexcept;
                 void initialize();
                 void finalize();
             private:
                 void waitForFinish();
                 class VariableControllerPrivate;
                 spimpl::unique_impl_ptr<VariableControllerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLECONTROLLER_H

core/src/Variable/Variable.cpp +1 -1

             #include "Variable/Variable.h"
             #include <Data/IDataSeries.h>
             #include <Data/SqpDateTime.h>
             Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
             struct Variable::VariablePrivate {
                 explicit VariablePrivate(const QString &name, const QString &unit, const QString &mission,
                                          const SqpDateTime &dateTime)
                         : m_Name{name},
                           m_Unit{unit},
                           m_Mission{mission},
                           m_DateTime{dateTime},
                           m_DataSeries{nullptr}
                 {
                 }
                 QString m_Name;
                 QString m_Unit;
                 QString m_Mission;
                 SqpDateTime m_DateTime; // The dateTime available in the view and loaded. not the cache.
                 std::unique_ptr<IDataSeries> m_DataSeries;
             };
             Variable::Variable(const QString &name, const QString &unit, const QString &mission,
                                const SqpDateTime &dateTime)
                     : impl{spimpl::make_unique_impl<VariablePrivate>(name, unit, mission, dateTime)}
             {
             }
             QString Variable::name() const noexcept
             {
                 return impl->m_Name;
             }
             QString Variable::mission() const noexcept
             {
                 return impl->m_Mission;
             }
             QString Variable::unit() const noexcept
             {
                 return impl->m_Unit;
             }
             SqpDateTime Variable::dateTime() const noexcept
             {
                 return impl->m_DateTime;
             }
             void Variable::setDateTime(const SqpDateTime &dateTime) noexcept
             {
                 impl->m_DateTime = dateTime;
             }
             void Variable::setDataSeries(std::unique_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (!impl->m_DataSeries) {
                     impl->m_DataSeries = std::move(dataSeries);
                 }
             }
             void Variable::onAddDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (impl->m_DataSeries) {
                     impl->m_DataSeries->merge(dataSeries.get());
-                    emit dataCacheUpdated();
+                    emit updated();
                 }
             }
             IDataSeries *Variable::dataSeries() const noexcept
             {
                 return impl->m_DataSeries.get();
             }
             bool Variable::contains(const SqpDateTime &dateTime)
             {
                 return impl->m_DateTime.contains(dateTime);
             }
             bool Variable::intersect(const SqpDateTime &dateTime)
             {
                 return impl->m_DateTime.intersect(dateTime);
             }

core/src/Variable/VariableController.cpp +12 -19

             #include <Variable/Variable.h>
             #include <Variable/VariableCacheController.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Time/TimeController.h>
             #include <QDateTime>
-            #include <QElapsedTimer>
             #include <QMutex>
             #include <QThread>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             /// @todo Generates default dataseries, according to the provider passed in parameter. This method
             /// will be deleted when the timerange is recovered from SciQlop
             std::unique_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
                                                                    const SqpDateTime &dateTime) noexcept
             {
                 auto parameters = DataProviderParameters{dateTime};
                 return provider.retrieveData(parameters);
             }
             } // namespace
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableCacheController{std::make_unique<VariableCacheController>()}
                 {
                 }
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheController> m_VariableCacheController;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             void VariableController::createVariable(const QString &name,
                                                     std::shared_ptr<IDataProvider> provider) noexcept
             {
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return;
                 }
                 /// @todo : for the moment :
                 /// - the provider is only used to retrieve data from the variable for its initialization, but
                 /// it will be retained later
                 /// - default data are generated for the variable, without taking into account the timerange set
                 /// in sciqlop
                 auto dateTime = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(
                         name, dateTime, generateDefaultDataSeries(*provider, dateTime))) {
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     qRegisterMetaType<std::shared_ptr<IDataSeries> >();
                     qRegisterMetaType<SqpDateTime>();
                     connect(provider.get(), &IDataProvider::dataProvided, newVariable.get(),
                             &Variable::onAddDataSeries);
                     // store in cache
                     impl->m_VariableCacheController->addDateTime(newVariable, dateTime);
                     // notify the creation
                     emit variableCreated(newVariable);
                 }
             }
-            void VariableController::requestDataLoading(std::shared_ptr<Variable> variable,
+            void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
-                                                        const SqpDateTime &dateTime)
+                                                          const SqpDateTime &dateTime)
             {
                 // we want to load data of the variable for the dateTime.
                 // First we check if the cache contains some of them.
                 // For the other, we ask the provider to give them.
                 if (variable) {
-                    QElapsedTimer timer;
-                    timer.start();
-                    qCInfo(LOG_VariableController()) << "TORM: The slow s0 operation took" << timer.elapsed()
-                                                     << "milliseconds";
                     auto dateTimeListNotInCache
                         = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
-                    qCInfo(LOG_VariableController()) << "TORM: The slow s1 operation took" << timer.elapsed()
-                                                     << "milliseconds";
-                    // Ask the provider for each data on the dateTimeListNotInCache
+                    if (!dateTimeListNotInCache.empty()) {
-                    impl->m_VariableToProviderMap.at(variable)->requestDataLoading(dateTimeListNotInCache);
+                        // Ask the provider for each data on the dateTimeListNotInCache
+                        impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
-                    qCInfo(LOG_VariableController()) << "TORM: The slow s2 operation took" << timer.elapsed()
+                            std::move(dateTimeListNotInCache));
-                                                     << "milliseconds";
+                        // store in cache
+                        impl->m_VariableCacheController->addDateTime(variable, dateTime);
-                    // store in cache
-                    impl->m_VariableCacheController->addDateTime(variable, dateTime);
+                    else {
-                    qCInfo(LOG_VariableController()) << "TORM: The slow s3 operation took" << timer.elapsed()
+                        emit variable->updated();
-                                                     << "milliseconds";
                 }
                 else {
                     qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
                 }
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }

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

             #ifndef SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #define SCIQLOP_VISUALIZATIONGRAPHWIDGET_H
             #include "Visualization/IVisualizationWidget.h"
             #include <QLoggingCategory>
             #include <QWidget>
             #include <memory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationGraphWidget)
             class QCPRange;
+            class SqpDateTime;
             class Variable;
             namespace Ui {
             class VisualizationGraphWidget;
             } // namespace Ui
             class VisualizationGraphWidget : public QWidget, public IVisualizationWidget {
                 Q_OBJECT
             public:
                 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
                 void addVariable(std::shared_ptr<Variable> variable);
                 /// Removes a variable from the graph
                 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
                 QString name() const override;
                 void updateDisplay(std::shared_ptr<Variable> variable);
+            signals:
+                void requestDataLoading(std::shared_ptr<Variable> variable, const SqpDateTime &dateTime);
             private:
                 Ui::VisualizationGraphWidget *ui;
                 class VisualizationGraphWidgetPrivate;
                 spimpl::unique_impl_ptr<VisualizationGraphWidgetPrivate> impl;
             private slots:
                 /// Slot called when right clicking on the graph (displays a menu)
                 void onGraphMenuRequested(const QPoint &pos) noexcept;
                 void onRangeChanged(const QCPRange &t1, const QCPRange &t2);
                 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
                 void onMouseWheel(QWheelEvent *event) noexcept;
                 void onDataCacheVariableUpdated();
             };
             #endif // SCIQLOP_VISUALIZATIONGRAPHWIDGET_H

gui/src/Visualization/VisualizationGraphHelper.cpp +15 -13

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarSeries.h>
             #include <Variable/Variable.h>
             #include <QElapsedTimer>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             namespace {
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
             /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
             /// non-time data
             QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
             {
                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
                     return dateTicker;
                 }
                 else {
                     // default ticker
                     return QSharedPointer<QCPAxisTicker>::create();
                 }
             }
             void updateScalarData(QCPAbstractPlottable *component, ScalarSeries &scalarSeries,
                                   const SqpDateTime &dateTime)
             {
                 QElapsedTimer timer;
                 timer.start();
                 if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
                     // Clean the graph
-                    qCDebug(LOG_VisualizationGraphHelper()) << "The slow s1 operation took" << timer.elapsed()
-                                                            << "milliseconds";
                     // NAIVE approch
                     const auto &xData = scalarSeries.xAxisData()->data();
                     const auto &valuesData = scalarSeries.valuesData()->data();
+                    const auto count = xData.count();
+                    qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points in cache" << xData.count();
-                    auto xValue = QVector<double>();
+                    auto xValue = QVector<double>(count);
-                    auto vValue = QVector<double>();
+                    auto vValue = QVector<double>(count);
-                    const auto count = xData.count();
+                    int n = 0;
-                    auto ite = 0;
                     for (auto i = 0; i < count; ++i) {
-                        const auto x = xData.at(i);
+                        const auto x = xData[i];
                         if (x >= dateTime.m_TStart && x <= dateTime.m_TEnd) {
-                            xValue.push_back(x);
+                            xValue[n] = x;
-                            vValue.push_back(valuesData.at(i));
+                            vValue[n] = valuesData[i];
-                            ++ite;
+                            ++n;
                         }
                     }
-                    qcpGraph->setData(xValue, vValue);
+                    xValue.resize(n);
+                    vValue.resize(n);
-                    qCDebug(LOG_VisualizationGraphHelper()) << "The slow s2 operation took" << timer.elapsed()
+                    qCInfo(LOG_VisualizationGraphHelper()) << "TORM: Current points displayed"
-                                                            << "milliseconds";
+                                                           << xValue.count();
+                    qcpGraph->setData(xValue, vValue);
                 }
                 else {
                     /// @todo DEBUG
                 }
             }
             QCPAbstractPlottable *createScalarSeriesComponent(ScalarSeries &scalarSeries, QCustomPlot &plot,
                                                               const SqpDateTime &dateTime)
             {
                 auto component = plot.addGraph();
                 if (component) {
                     //        // Graph data
                     component->setData(scalarSeries.xAxisData()->data(), scalarSeries.valuesData()->data(),
                                        true);
                     updateScalarData(component, scalarSeries, dateTime);
                     // Axes properties
                     /// @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 setAxisProperties = [](auto axis, const auto &unit) {
                         // label (unit name)
                         axis->setLabel(unit.m_Name);
                         // ticker (depending on the type of unit)
                         axis->setTicker(axisTicker(unit.m_TimeUnit));
                     };
                     setAxisProperties(plot.xAxis, scalarSeries.xAxisUnit());
                     setAxisProperties(plot.yAxis, scalarSeries.valuesUnit());
                     // Display all data
                     component->rescaleAxes();
                     plot.replot();
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph for the scalar series");
                 }
                 return component;
             }
             } // namespace
             QVector<QCPAbstractPlottable *> VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
                                                                              QCustomPlot &plot) noexcept
             {
                 auto result = QVector<QCPAbstractPlottable *>{};
                 if (variable) {
                     // Gets the data series of the variable to call the creation of the right components
                     // according to its type
                     if (auto scalarSeries = dynamic_cast<ScalarSeries *>(variable->dataSeries())) {
                         result.append(createScalarSeriesComponent(*scalarSeries, plot, variable->dateTime()));
                     }
                     else {
                         qCDebug(LOG_VisualizationGraphHelper())
                             << QObject::tr("Can't create graph plottables : unmanaged data series type");
                     }
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                 }
                 return result;
             }
             void VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *> plotableVect,
                                                       IDataSeries *dataSeries, const SqpDateTime &dateTime)
             {
                 if (auto scalarSeries = dynamic_cast<ScalarSeries *>(dataSeries)) {
                     if (plotableVect.size() == 1) {
                         updateScalarData(plotableVect.at(0), *scalarSeries, dateTime);
                     }
                     else {
                         qCCritical(LOG_VisualizationGraphHelper()) << QObject::tr(
                             "Can't update Data of a scalarSeries because there is not only one component "
                             "associated");
                     }
                 }
                 else {
                     /// @todo DEBUG
                 }
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +5 -6

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <SqpApplication.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 {
                 // 1 variable -> n qcpplot
                 std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->graphNameLabel->setText(name);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationGraphWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // 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);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 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);
                 // 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);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 for (auto createdPlottable : qAsConst(createdPlottables)) {
                     impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                 }
-                connect(variable.get(), SIGNAL(dataCacheUpdated()), this, SLOT(onDataCacheVariableUpdated()));
+                connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
             }
             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 componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
                 for (auto it = componentsIt.first; it != componentsIt.second;) {
                     ui->widget->removePlottable(it->second);
                     it = impl->m_VariableToPlotMultiMap.erase(it);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             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;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return ui->graphNameLabel->text();
             }
             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(mapToGlobal(pos));
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged");
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                     auto variable = it->first;
-                    qCInfo(LOG_VisualizationGraphWidget())
-                        << tr("TORM: VisualizationGraphWidget::onRangeChanged")
-                        << variable->dataSeries()->xAxisData()->size();
                     auto dateTime = SqpDateTime{t2.lower, t2.upper};
                     if (!variable->contains(dateTime)) {
                         auto variableDateTimeWithTolerance = dateTime;
                         if (variable->intersect(dateTime)) {
                             auto variableDateTime = variable->dateTime();
                             if (variableDateTime.m_TStart < dateTime.m_TStart) {
                                 auto diffEndToKeepDelta = dateTime.m_TEnd - variableDateTime.m_TEnd;
                                 dateTime.m_TStart = variableDateTime.m_TStart + diffEndToKeepDelta;
                                 // Tolerance have to be added to the right
                                 // add 10% tolerance for right (end) side
                                 auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                                 variableDateTimeWithTolerance.m_TEnd += tolerance;
                             }
                             if (variableDateTime.m_TEnd > dateTime.m_TEnd) {
                                 auto diffStartToKeepDelta = variableDateTime.m_TStart - dateTime.m_TStart;
                                 dateTime.m_TEnd = variableDateTime.m_TEnd - diffStartToKeepDelta;
                                 // Tolerance have to be added to the left
                                 // add 10% tolerance for left (start) side
                                 auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                                 variableDateTimeWithTolerance.m_TStart -= tolerance;
                             }
                         }
                         else {
                             // add 10% tolerance for each side
                             auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                             variableDateTimeWithTolerance.m_TStart -= tolerance;
                             variableDateTimeWithTolerance.m_TEnd += tolerance;
                         }
                         variable->setDateTime(dateTime);
                         // CHangement detected, we need to ask controller to request data loading
-                        sqpApp->variableController().requestDataLoading(variable,
+                        emit requestDataLoading(variable, variableDateTimeWithTolerance);
-                                                                        variableDateTimeWithTolerance);
                     }
                 }
             }
             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::onDataCacheVariableUpdated()
             {
                 // NOTE:
                 //    We don't want to call the method for each component of a variable unitarily, but for
                 //    all
                 //    its components at once (eg its three components in the case of a vector).
                 //    The unordered_multimap does not do this easily, so the question is whether to:
                 //    - use an ordered_multimap and the algos of std to group the values by key
                 //    - use a map (unique keys) and store as values directly the list of components
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                     auto variable = it->first;
                     VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
                                                          variable->dataSeries(), variable->dateTime());
                 }
             }
             void VisualizationGraphWidget::updateDisplay(std::shared_ptr<Variable> variable)
             {
                 auto abstractPlotableItPair = impl->m_VariableToPlotMultiMap.equal_range(variable);
                 auto abstractPlotableVect = QVector<QCPAbstractPlottable *>{};
                 for (auto it = abstractPlotableItPair.first; it != abstractPlotableItPair.second; ++it) {
                     abstractPlotableVect.push_back(it->second);
                 }
                 VisualizationGraphHelper::updateData(abstractPlotableVect, variable->dataSeries(),
                                                      variable->dateTime());
             }

plugins/mockplugin/src/CosinusProvider.cpp +9 -6

             #include "CosinusProvider.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <cmath>
+            #include <QDateTime>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
             std::unique_ptr<IDataSeries>
             CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
             {
                 auto dateTime = parameters.m_Time;
                 // Gets the timerange from the parameters
                 auto start = dateTime.m_TStart;
                 auto end = dateTime.m_TEnd;
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second)
                 auto scalarSeries
                     = std::make_unique<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
                 auto dataIndex = 0;
                 for (auto time = start; time < end; ++time, ++dataIndex) {
                     scalarSeries->setData(dataIndex, time, std::cos(time));
                 }
                 return scalarSeries;
             }
             void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
             {
                 // NOTE: Try to use multithread if possible
                 for (const auto &dateTime : dateTimeList) {
                     auto scalarSeries = this->retrieveDataSeries(dateTime);
                     emit dataProvided(scalarSeries, dateTime);
                 }
             }
             std::shared_ptr<IDataSeries> CosinusProvider::retrieveDataSeries(const SqpDateTime &dateTime)
             {
+                auto dataIndex = 0;
                 // Gets the timerange from the parameters
-                auto start = dateTime.m_TStart;
+                double freq = 100.0;
-                auto end = dateTime.m_TEnd;
+                double start = dateTime.m_TStart * freq; // 100 htz
+                double end = dateTime.m_TEnd * freq;     // 100 htz
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second)
                 auto scalarSeries
                     = std::make_shared<ScalarSeries>(end - start, Unit{QStringLiteral("t"), true}, Unit{});
-                auto dataIndex = 0;
                 for (auto time = start; time < end; ++time, ++dataIndex) {
-                    scalarSeries->setData(dataIndex, time, std::cos(time));
+                    const auto timeOnFreq = time / freq;
+                    scalarSeries->setData(dataIndex, timeOnFreq, std::cos(timeOnFreq));
                 }
                 return scalarSeries;
             }

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