GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r903:8f094eaa3c04

Refactors VisualizationGraphWidget::setYRange()...

Alexandre Leroux -

r903:8f094eaa3c04

parent child

Context file:

r903:8f094eaa3c04

Collapse all files

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

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

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

                  /// Returns the list of all variables used in the graph
                  QList<std::shared_ptr<Variable> > variables() const;
-                 void setYRange(const SqpRange &range);
+                 /// Sets the y-axis range based on the data of a variable
+                 void setYRange(std::shared_ptr<Variable> variable);
                  SqpRange graphRange() const noexcept;
                  void setGraphRange(const SqpRange &range);

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

               */
              template <typename T, typename Enabled = void>
              struct PlottablesUpdater {
+                 static void setPlotYAxisRange(T &, const SqpRange &, QCustomPlot &)
+                 {
+                     qCCritical(LOG_DataSeries())
+                         << QObject::tr("Can't set plot y-axis range: unmanaged data series type");
+                 }
                  static void updatePlottables(T &, PlottablesMap &, const SqpRange &, bool)
                  {
                      qCCritical(LOG_DataSeries())
              struct PlottablesUpdater<T,
                                       typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                                 or std::is_base_of<VectorSeries, T>::value> > {
+                 static void setPlotYAxisRange(T &dataSeries, const SqpRange &xAxisRange, QCustomPlot &plot)
+                 {
+                     auto minValue = 0., maxValue = 0.;
+                     dataSeries.lockRead();
+                     auto valuesBounds = dataSeries.valuesBounds(xAxisRange.m_TStart, xAxisRange.m_TEnd);
+                     auto end = dataSeries.cend();
+                     if (valuesBounds.first != end && valuesBounds.second != end) {
+                         auto rangeValue = [](const auto &value) { return std::isnan(value) ? 0. : value; };
+                         minValue = rangeValue(valuesBounds.first->minValue());
+                         maxValue = rangeValue(valuesBounds.second->maxValue());
+                     }
+                     dataSeries.unlock();
+                     plot.yAxis->setRange(QCPRange{minValue, maxValue});
+                 }
                  static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const SqpRange &range,
                                               bool rescaleAxes)
                  {
              struct IPlottablesHelper {
                  virtual ~IPlottablesHelper() noexcept = default;
                  virtual PlottablesMap create(QCustomPlot &plot) const = 0;
+                 virtual void setYAxisRange(const SqpRange &xAxisRange, QCustomPlot &plot) const = 0;
                  virtual void update(PlottablesMap &plottables, const SqpRange &range,
                                      bool rescaleAxes = false) const = 0;
              };
                      PlottablesUpdater<T>::updatePlottables(m_DataSeries, plottables, range, rescaleAxes);
                  }
+                 void setYAxisRange(const SqpRange &xAxisRange, QCustomPlot &plot) const override
+                 {
+                     return PlottablesUpdater<T>::setPlotYAxisRange(m_DataSeries, xAxisRange, plot);
+                 }
                  T &m_DataSeries;
              };
                  }
              }
+             void VisualizationGraphHelper::setYAxisRange(std::shared_ptr<Variable> variable,
+                                                          QCustomPlot &plot) noexcept
+             {
+                 if (variable) {
+                     auto helper = createHelper(variable->dataSeries());
+                     helper->setYAxisRange(variable->range(), plot);
+                 }
+                 else {
+                     qCDebug(LOG_VisualizationGraphHelper())
+                         << QObject::tr("Can't set y-axis range of plot: the variable is null");
+                 }
+             }
              void VisualizationGraphHelper::updateData(PlottablesMap &plottables,
                                                        std::shared_ptr<IDataSeries> dataSeries,
                                                        const SqpRange &dateTime)

gui/src/Visualization/VisualizationGraphWidget.cpp +7 -2

                  return variables;
              }
-             void VisualizationGraphWidget::setYRange(const SqpRange &range)
+             void VisualizationGraphWidget::setYRange(std::shared_ptr<Variable> variable)
              {
-                 ui->widget->yAxis->setRange(range.m_TStart, range.m_TEnd);
+                 if (!variable) {
+                     qCCritical(LOG_VisualizationGraphWidget()) << "Can't set y-axis range: variable is null";
+                     return;
+                 }
+                 VisualizationGraphHelper::setYAxisRange(variable, *ui->widget);
              }
              SqpRange VisualizationGraphWidget::graphRange() const noexcept

gui/src/Visualization/VisualizationZoneWidget.cpp +1 -17

                  this->insertGraph(index, graphWidget);
                  graphWidget->addVariable(variable, range);
-                 // get y using variable range
-                 if (auto dataSeries = variable->dataSeries()) {
-                     dataSeries->lockRead();
-                     auto valuesBounds
-                         = dataSeries->valuesBounds(variable->range().m_TStart, variable->range().m_TEnd);
-                     auto end = dataSeries->cend();
-                     if (valuesBounds.first != end && valuesBounds.second != end) {
-                         auto rangeValue = [](const auto &value) { return std::isnan(value) ? 0. : value; };
-                         auto minValue = rangeValue(valuesBounds.first->minValue());
-                         auto maxValue = rangeValue(valuesBounds.second->maxValue());
-                         graphWidget->setYRange(SqpRange{minValue, maxValue});
+                     }
-                     dataSeries->unlock();
+                 }
+                 graphWidget->setYRange(variable);
                  return graphWidget;
              }

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