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 +62 -41

               */
              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");
                  }
              };
-             /**
-              * Specialization of PlottablesCreator for scalars and vectors
-              * @sa ScalarSeries
-              * @sa VectorSeries
-              */
-             template <typename T>
-             struct PlottablesCreator<T,
-                                      typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
-                                                                or std::is_base_of<VectorSeries, T>::value> > {
-                 static PlottablesMap createPlottables(T &dataSeries, QCustomPlot &plot)
+             PlottablesMap createGraphs(QCustomPlot &plot, int nbGraphs)
                  {
-                     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) {
+                 // Creates {nbGraphs} QCPGraph to add to the plot
+                 for (auto i = 0; i < nbGraphs; ++i) {
-                         auto graph = plot.addGraph();
-                         result.insert({i, graph});
-                     }
-                     return result;
                  }
+             /**
+              * Specialization of PlottablesCreator for scalars
+              * @sa ScalarSeries
+              */
+             template <typename T>
+             struct PlottablesCreator<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value> > {
+                 static PlottablesMap createPlottables(QCustomPlot &plot) { return createGraphs(plot, 1); }
+             };
+             /**
+              * 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
-             std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<IDataSeries> dataSeries) noexcept
+             /// Creates IPlottablesHelper according to the type of data series a variable holds
+             std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<Variable> variable) noexcept
              {
-                 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
-                     return std::make_unique<PlottablesHelper<ScalarSeries> >(*scalarSeries);
+                 }
-                 else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
-                     return std::make_unique<PlottablesHelper<SpectrogramSeries> >(*spectrogramSeries);
+                 }
-                 else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
-                     return std::make_unique<PlottablesHelper<VectorSeries> >(*vectorSeries);
+                 }
-                 else {
-                     return std::make_unique<PlottablesHelper<IDataSeries> >(*dataSeries);
+                 switch (variable->type()) {
+                     case DataSeriesType::SCALAR:
+                         return std::make_unique<PlottablesHelper<ScalarSeries> >(
+                             std::dynamic_pointer_cast<ScalarSeries>(variable->dataSeries()));
+                     case DataSeriesType::SPECTROGRAM:
+                         return std::make_unique<PlottablesHelper<SpectrogramSeries> >(
+                             std::dynamic_pointer_cast<SpectrogramSeries>(variable->dataSeries()));
+                     case DataSeriesType::VECTOR:
+                         return std::make_unique<PlottablesHelper<VectorSeries> >(
+                             std::dynamic_pointer_cast<VectorSeries>(variable->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