HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r321:b1c50789867a

Merge pull request from SCIQLOP-Initialisation develop...

leroux -

r321:b1c50789867a

parent child

Context file:

r321:b1c50789867a

Collapse all files

core/include/Data/SqpDateTime.h +2 -2

                 /// End time
                 double m_TEnd;
-                bool contains(const SqpDateTime &dateTime)
+                bool contains(const SqpDateTime &dateTime) const noexcept
                 {
                     return (m_TStart <= dateTime.m_TStart && m_TEnd >= dateTime.m_TEnd);
                 }
-                bool intersect(const SqpDateTime &dateTime)
+                bool intersect(const SqpDateTime &dateTime) const noexcept
                 {
                     return (m_TEnd >= dateTime.m_TStart && m_TStart <= dateTime.m_TEnd);
                 }

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

                 /// @return the data of the variable, nullptr if there is no data
                 IDataSeries *dataSeries() const noexcept;
-                bool contains(const SqpDateTime &dateTime);
+                bool contains(const SqpDateTime &dateTime) const noexcept;
-                bool intersect(const SqpDateTime &dateTime);
+                bool intersect(const SqpDateTime &dateTime) const noexcept;
+                bool isInside(const SqpDateTime &dateTime) const noexcept;
             public slots:
                 void setDataSeries(std::shared_ptr<IDataSeries> dataSeries) noexcept;

core/include/Variable/VariableModel.h +2 -4

                  * Creates a new variable in the model
                  * @param name the name of the new variable
                  * @param dateTime the dateTime of the new variable
-                 * @param defaultDataSeries the default data of the new variable
                  * @return the pointer to the new variable
                  */
-                std::shared_ptr<Variable>
+                std::shared_ptr<Variable> createVariable(const QString &name,
-                createVariable(const QString &name, const SqpDateTime &dateTime,
+                                                         const SqpDateTime &dateTime) noexcept;
-                               std::shared_ptr<IDataSeries> defaultDataSeries) noexcept;
                 std::shared_ptr<Variable> variable(int index) const;

core/src/Variable/Variable.cpp +7 -2

                 return impl->m_DataSeries.get();
             }
-            bool Variable::contains(const SqpDateTime &dateTime)
+            bool Variable::contains(const SqpDateTime &dateTime) const noexcept
             {
                 return impl->m_DateTime.contains(dateTime);
             }
-            bool Variable::intersect(const SqpDateTime &dateTime)
+            bool Variable::intersect(const SqpDateTime &dateTime) const noexcept
             {
                 return impl->m_DateTime.intersect(dateTime);
             }
+            bool Variable::isInside(const SqpDateTime &dateTime) const noexcept
+            {
+                return dateTime.contains(SqpDateTime{impl->m_DateTime.m_TStart, impl->m_DateTime.m_TEnd});
+            }

core/src/Variable/VariableCacheController.cpp +6 -7

                                                      impl->m_VariableToSqpDateTimeListMap.at(variable), 0);
                         }
                         catch (const std::out_of_range &e) {
-                            qCWarning(LOG_VariableCacheController()) << e.what();
+                            qCWarning(LOG_VariableCacheController()) << "addDateTime" << e.what();
                         }
                     }
                 }
                 // list of date time request associated to the variable
                 // We assume that the list is ordered in a way that l(0) < l(1). We assume also a < b
                 // (with a & b of type SqpDateTime) means ts(b) > te(a)
+                auto it = impl->m_VariableToSqpDateTimeListMap.find(variable);
-                try {
+                if (it != impl->m_VariableToSqpDateTimeListMap.end()) {
-                    impl->addInCacheDataByStart(dateTime, impl->m_VariableToSqpDateTimeListMap.at(variable),
+                    impl->addInCacheDataByStart(dateTime, it->second, notInCache, 0, dateTime.m_TStart);
-                                                notInCache, 0, dateTime.m_TStart);
                 }
-                catch (const std::out_of_range &e) {
+                else {
-                    qCWarning(LOG_VariableCacheController()) << e.what();
+                    notInCache << dateTime;
                 }
                 return notInCache;

core/src/Variable/VariableController.cpp +10 -8

                 /// - 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(
+                if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime)) {
-                        name, dateTime, generateDefaultDataSeries(*provider, dateTime))) {
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
-                    connect(provider.get(), &IDataProvider::dataProvided, newVariable.get(),
-                            &Variable::setDataSeries);
+                    auto addDateTimeAcquired
+                        = [this, newVariable](auto dataSeriesAcquired, auto dateTimeToPutInCache) {
-                    // store in cache
+                              impl->m_VariableCacheController->addDateTime(newVariable, dateTimeToPutInCache);
-                    impl->m_VariableCacheController->addDateTime(newVariable, dateTime);
+                              newVariable->setDataSeries(dataSeriesAcquired);
+                          };
+                    connect(provider.get(), &IDataProvider::dataProvided, addDateTimeAcquired);
+                    this->onRequestDataLoading(newVariable, dateTime);
                     // notify the creation
                     emit variableCreated(newVariable);
                         // Ask the provider for each data on the dateTimeListNotInCache
                         impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
                             std::move(dateTimeListNotInCache));
-                        // store in cache
-                        impl->m_VariableCacheController->addDateTime(variable, dateTime);
                     }
                     else {
                         emit variable->updated();

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

             {
             }
-            std::shared_ptr<Variable>
+            std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
-            VariableModel::createVariable(const QString &name, const SqpDateTime &dateTime,
+                                                                    const SqpDateTime &dateTime) noexcept
-                                          std::shared_ptr<IDataSeries> defaultDataSeries) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
                 /// @todo For the moment, the other data of the variable is initialized with default values
                 auto variable = std::make_shared<Variable>(name, QStringLiteral("unit"),
                                                            QStringLiteral("mission"), dateTime);
-                variable->setDataSeries(std::move(defaultDataSeries));
                 impl->m_Variables.push_back(variable);

gui/include/Visualization/VisualizationGraphWidget.h +2 -1

                 virtual ~VisualizationGraphWidget();
                 void addVariable(std::shared_ptr<Variable> variable);
+                void addVariableUsingGraph(std::shared_ptr<Variable> variable);
                 /// Removes a variable from the graph
                 void removeVariable(std::shared_ptr<Variable> variable) noexcept;
                 /// 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);
+                void onRangeChanged(const QCPRange &t1);
                 /// Slot called when a mouse wheel was made, to perform some processing before the zoom is done
                 void onMouseWheel(QWheelEvent *event) noexcept;

gui/src/Visualization/VisualizationGraphHelper.cpp +4 -2

                     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>(count);
                     auto vValue = QVector<double>(count);
                                                            << xValue.count();
                     qcpGraph->setData(xValue, vValue);
+                    // Display all data
+                    component->rescaleAxes();
+                    component->parentPlot()->replot();
                 }
                 else {
                     /// @todo DEBUG
                     // Display all data
                     component->rescaleAxes();
                     plot.replot();
                 }
                 else {

gui/src/Visualization/VisualizationGraphWidget.cpp +45 -8

                 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 &)>(
+                connect(ui->widget->xAxis,
-                                               &QCPAxis::rangeChanged),
+                        static_cast<void (QCPAxis::*)(const QCPRange &)>(&QCPAxis::rangeChanged), this,
-                        this, &VisualizationGraphWidget::onRangeChanged);
+                        &VisualizationGraphWidget::onRangeChanged);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
             }
+            void VisualizationGraphWidget::addVariableUsingGraph(std::shared_ptr<Variable> variable)
+            {
+                // when adding a variable, we need to set its time range to the current graph range
+                auto grapheRange = ui->widget->xAxis->range();
+                auto dateTime = SqpDateTime{grapheRange.lower, grapheRange.upper};
+                variable->setDateTime(dateTime);
+                auto variableDateTimeWithTolerance = dateTime;
+                // add 10% tolerance for each side
+                auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
+                variableDateTimeWithTolerance.m_TStart -= tolerance;
+                variableDateTimeWithTolerance.m_TEnd += tolerance;
+                // 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(updated()), this, SLOT(onDataCacheVariableUpdated()));
+                // CHangement detected, we need to ask controller to request data loading
+                emit requestDataLoading(variable, variableDateTimeWithTolerance);
+            }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 // Each component associated to the variable :
                 }
             }
-            void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
+            void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::onRangeChanged");
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
                      it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
                     auto variable = it->first;
-                    auto dateTime = SqpDateTime{t2.lower, t2.upper};
+                    auto dateTime = SqpDateTime{t1.lower, t1.upper};
                     if (!variable->contains(dateTime)) {
                         auto variableDateTimeWithTolerance = dateTime;
-                        if (variable->intersect(dateTime)) {
+                        if (!variable->isInside(dateTime)) {
                             auto variableDateTime = variable->dateTime();
                             if (variableDateTime.m_TStart < dateTime.m_TStart) {
+                                qCDebug(LOG_VisualizationGraphWidget()) << tr("TDetection pan to right:");
                                 auto diffEndToKeepDelta = dateTime.m_TEnd - variableDateTime.m_TEnd;
                                 dateTime.m_TStart = variableDateTime.m_TStart + diffEndToKeepDelta;
                                 auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                                 variableDateTimeWithTolerance.m_TEnd += tolerance;
                             }
-                            if (variableDateTime.m_TEnd > dateTime.m_TEnd) {
+                            else if (variableDateTime.m_TEnd > dateTime.m_TEnd) {
+                                qCDebug(LOG_VisualizationGraphWidget()) << tr("Detection pan to left: ");
                                 auto diffStartToKeepDelta = variableDateTime.m_TStart - dateTime.m_TStart;
                                 dateTime.m_TEnd = variableDateTime.m_TEnd - diffStartToKeepDelta;
                                 // Tolerance have to be added to the left
                                 auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                                 variableDateTimeWithTolerance.m_TStart -= tolerance;
                             }
+                            else {
+                                qCWarning(LOG_VisualizationGraphWidget())
+                                    << tr("Detection anormal zoom detection: ");
+                            }
                         }
                         else {
+                            qCDebug(LOG_VisualizationGraphWidget()) << tr("Detection zoom out: ");
                             // add 10% tolerance for each side
                             auto tolerance = 0.1 * (dateTime.m_TEnd - dateTime.m_TStart);
                             variableDateTimeWithTolerance.m_TStart -= tolerance;
                         // CHangement detected, we need to ask controller to request data loading
                         emit requestDataLoading(variable, variableDateTimeWithTolerance);
                     }
+                    else {
+                        qCDebug(LOG_VisualizationGraphWidget()) << tr("Detection zoom in: ");
+                    }
                 }
             }

gui/src/Visualization/operations/GenerateVariableMenuOperation.cpp +1 -1

                 if (graphWidget) {
                     impl->visitLeaf(
                         *graphWidget, QObject::tr("Open in %1").arg(graphWidget->name()),
-                        [ var = impl->m_Variable, graphWidget ]() { graphWidget->addVariable(var); });
+                        [ var = impl->m_Variable, graphWidget ]() { graphWidget->addVariableUsingGraph(var); });
                 }
                 else {
                     qCCritical(LOG_GenerateVariableMenuOperation(),

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