HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1251:3d74b7d22319

Updates VisualizationGraphHelper to use variable's type instead of dataseries

Alexandre Leroux -

r1251:3d74b7d22319

parent child

Context file:

r1251:3d74b7d22319

Collapse all files

gui/include/Visualization/VisualizationGraphHelper.h +1 -1

                  */
                 static PlottablesMap create(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept;
-                static void updateData(PlottablesMap &plottables, std::shared_ptr<IDataSeries> dataSeries,
+                static void updateData(PlottablesMap &plottables, std::shared_ptr<Variable> variable,
                                        const SqpRange &dateTime);
                 static void setYAxisRange(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept;

gui/src/Visualization/VisualizationGraphHelper.cpp +68 -47

              */
             template <typename T, typename Enabled = void>
             struct PlottablesCreator {
-                static PlottablesMap createPlottables(T &, QCustomPlot &)
+                static PlottablesMap createPlottables(QCustomPlot &)
                 {
                     qCCritical(LOG_DataSeries())
                         << QObject::tr("Can't create plottables: unmanaged data series type");
                 }
             };
+            PlottablesMap createGraphs(QCustomPlot &plot, int nbGraphs)
+            {
+                PlottablesMap result{};
+                // Creates {nbGraphs} QCPGraph to add to the plot
+                for (auto i = 0; i < nbGraphs; ++i) {
+                    auto graph = plot.addGraph();
+                    result.insert({i, graph});
+                }
+                plot.replot();
+                return result;
+            }
             /**
-             * Specialization of PlottablesCreator for scalars and vectors
+             * Specialization of PlottablesCreator for scalars
              * @sa ScalarSeries
-             * @sa VectorSeries
              */
             template <typename T>
-            struct PlottablesCreator<T,
+            struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value> > {
-                                     typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
+                static PlottablesMap createPlottables(QCustomPlot &plot) { return createGraphs(plot, 1); }
-                                                               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();
-                    // 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();
-                        result.insert({i, graph});
-                    plot.replot();
-                    return result;
+            /**
+             * Specialization of PlottablesCreator for vectors
+             * @sa VectorSeries
+             */
+            template <typename T>
+            struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<VectorSeries, T>::value> > {
+                static PlottablesMap createPlottables(QCustomPlot &plot) { return createGraphs(plot, 3); }
             };
             /**
             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)
+                static PlottablesMap createPlottables(QCustomPlot &plot)
                 {
                     PlottablesMap result{};
                     result.insert({0, new QCPColorMap{plot.xAxis, plot.yAxis}});
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper {
-                explicit PlottablesHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
+                explicit PlottablesHelper(std::shared_ptr<T> dataSeries) : m_DataSeries{dataSeries} {}
                 PlottablesMap create(QCustomPlot &plot) const override
                 {
-                    return PlottablesCreator<T>::createPlottables(m_DataSeries, plot);
+                    return PlottablesCreator<T>::createPlottables(plot);
                 }
                 void update(PlottablesMap &plottables, const SqpRange &range, bool rescaleAxes) const override
                 {
-                    PlottablesUpdater<T>::updatePlottables(m_DataSeries, plottables, range, rescaleAxes);
+                    if (m_DataSeries) {
+                        PlottablesUpdater<T>::updatePlottables(*m_DataSeries, plottables, range, rescaleAxes);
+                    }
+                    else {
+                        qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
+                                                                      "between the type of data series and the "
+                                                                      "type supposed";
+                    }
                 }
                 void setYAxisRange(const SqpRange &xAxisRange, QCustomPlot &plot) const override
                 {
-                    return PlottablesUpdater<T>::setPlotYAxisRange(m_DataSeries, xAxisRange, plot);
+                    if (m_DataSeries) {
+                        PlottablesUpdater<T>::setPlotYAxisRange(*m_DataSeries, xAxisRange, plot);
+                    }
+                    else {
+                        qCCritical(LOG_VisualizationGraphHelper()) << "Can't update plottables: inconsistency "
+                                                                      "between the type of data series and the "
+                                                                      "type supposed";
+                    }
                 }
-                T &m_DataSeries;
+                std::shared_ptr<T> m_DataSeries;
             };
-            /// Creates IPlottablesHelper according to a data series
+            /// Creates IPlottablesHelper according to the type of data series a variable holds
-            std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<IDataSeries> dataSeries) noexcept
+            std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<Variable> variable) noexcept
             {
-                if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
+                switch (variable->type()) {
-                    return std::make_unique<PlottablesHelper<ScalarSeries> >(*scalarSeries);
+                    case DataSeriesType::SCALAR:
+                        return std::make_unique<PlottablesHelper<ScalarSeries> >(
-                else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
+                            std::dynamic_pointer_cast<ScalarSeries>(variable->dataSeries()));
-                    return std::make_unique<PlottablesHelper<SpectrogramSeries> >(*spectrogramSeries);
+                    case DataSeriesType::SPECTROGRAM:
+                        return std::make_unique<PlottablesHelper<SpectrogramSeries> >(
-                else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
+                            std::dynamic_pointer_cast<SpectrogramSeries>(variable->dataSeries()));
-                    return std::make_unique<PlottablesHelper<VectorSeries> >(*vectorSeries);
+                    case DataSeriesType::VECTOR:
+                        return std::make_unique<PlottablesHelper<VectorSeries> >(
-                else {
+                            std::dynamic_pointer_cast<VectorSeries>(variable->dataSeries()));
-                    return std::make_unique<PlottablesHelper<IDataSeries> >(*dataSeries);
+                    default:
+                        // Creates default helper
+                        break;
                 }
+                return std::make_unique<PlottablesHelper<IDataSeries> >(nullptr);
             }
             } // namespace
                                                            QCustomPlot &plot) noexcept
             {
                 if (variable) {
-                    auto helper = createHelper(variable->dataSeries());
+                    auto helper = createHelper(variable);
                     auto plottables = helper->create(plot);
                     return plottables;
                 }
                                                          QCustomPlot &plot) noexcept
             {
                 if (variable) {
-                    auto helper = createHelper(variable->dataSeries());
+                    auto helper = createHelper(variable);
                     helper->setYAxisRange(variable->range(), plot);
                 }
                 else {
             }
             void VisualizationGraphHelper::updateData(PlottablesMap &plottables,
-                                                      std::shared_ptr<IDataSeries> dataSeries,
+                                                      std::shared_ptr<Variable> variable,
                                                       const SqpRange &dateTime)
             {
-                auto helper = createHelper(dataSeries);
+                auto helper = createHelper(variable);
                 helper->update(plottables, dateTime);
             }

gui/src/Visualization/VisualizationGraphWidget.cpp +4 -4

                 {
                 }
-                void updateData(PlottablesMap &plottables, std::shared_ptr<IDataSeries> dataSeries,
+                void updateData(PlottablesMap &plottables, std::shared_ptr<Variable> variable,
                                 const SqpRange &range)
                 {
-                    VisualizationGraphHelper::updateData(plottables, dataSeries, range);
+                    VisualizationGraphHelper::updateData(plottables, variable, range);
                     // Prevents that data has changed to update rendering
                     m_RenderingDelegate->onPlotUpdated();
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
                     if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
-                        impl->updateData(variableEntry.second, variable->dataSeries(), variable->range());
+                        impl->updateData(variableEntry.second, variable, variable->range());
                     }
                 }
             }
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end()) {
-                    impl->updateData(it->second, variable->dataSeries(), range);
+                    impl->updateData(it->second, variable, range);
                 }
             }

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