HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1252:cd191f594800

Updates AxisRenderingUtils to use variable's type instead of dataseries

Alexandre Leroux -

r1252:cd191f594800

parent child

Context file:

r1252:cd191f594800

Collapse all files

gui/include/Visualization/AxisRenderingUtils.h +9 -2

              class QCPAxis;
              class QCustomPlot;
              class SqpColorScale;
+             class Variable;
              /// Formats a data value according to the axis on which it is present
              QString formatValue(double value, const QCPAxis &axis);
                  /// @param plot the plot for which to set axe properties
                  /// @param colorScale the color scale for which to set properties
                  virtual void setProperties(QCustomPlot &plot, SqpColorScale &colorScale) = 0;
+                 /// Set the units of the plot's axes and the color scale associated to plot passed as
+                 /// parameters
+                 /// @param plot the plot for which to set axe units
+                 /// @param colorScale the color scale for which to set unit
+                 virtual void setUnits(QCustomPlot &plot, SqpColorScale &colorScale) = 0;
              };
              struct IAxisHelperFactory {
-                 /// Creates IAxisHelper according to a data series
-                 static std::unique_ptr<IAxisHelper> create(std::shared_ptr<IDataSeries> dataSeries) noexcept;
+                 /// Creates IPlottablesHelper according to the type of data series a variable holds
+                 static std::unique_ptr<IAxisHelper> create(const Variable &variable) noexcept;
              };
              #endif // SCIQLOP_AXISRENDERINGUTILS_H

gui/src/Visualization/AxisRenderingUtils.cpp +60 -30

              #include <Data/SpectrogramSeries.h>
              #include <Data/VectorSeries.h>
+             #include <Variable/Variable.h>
              #include <Visualization/SqpColorScale.h>
              #include <Visualization/qcustomplot.h>
               */
              template <typename T, typename Enabled = void>
              struct AxisSetter {
-                 static void setProperties(T &, QCustomPlot &, SqpColorScale &)
+                 static void setProperties(QCustomPlot &, SqpColorScale &)
                  {
                      // Default implementation does nothing
                      qCCritical(LOG_AxisRenderingUtils()) << "Can't set axis properties: unmanaged type of data";
                  }
+                 static void setUnits(T &, QCustomPlot &, SqpColorScale &)
+                 {
+                     // Default implementation does nothing
+                     qCCritical(LOG_AxisRenderingUtils()) << "Can't set axis units: unmanaged type of data";
+                 }
              };
              /**
              template <typename T>
              struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                             or std::is_base_of<VectorSeries, T>::value> > {
-                 static void setProperties(T &dataSeries, QCustomPlot &plot, SqpColorScale &)
+                 static void setProperties(QCustomPlot &, SqpColorScale &)
+                 {
+                     // Nothing to do
+                 }
+                 static void setUnits(T &dataSeries, QCustomPlot &plot, SqpColorScale &)
                  {
                      dataSeries.lockRead();
                      auto xAxisUnit = dataSeries.xAxisUnit();
               */
              template <typename T>
              struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
-                 static void setProperties(T &dataSeries, QCustomPlot &plot, SqpColorScale &colorScale)
+                 static void setProperties(QCustomPlot &plot, SqpColorScale &colorScale)
                  {
-                     dataSeries.lockRead();
-                     auto xAxisUnit = dataSeries.xAxisUnit();
-                     auto yAxisUnit = dataSeries.yAxisUnit();
-                     auto valuesUnit = dataSeries.valuesUnit();
-                     dataSeries.unlock();
-                     setAxisProperties(*plot.xAxis, xAxisUnit);
-                     setAxisProperties(*plot.yAxis, yAxisUnit, QCPAxis::stLogarithmic);
                      // Displays color scale in plot
                      plot.plotLayout()->insertRow(0);
                      plot.plotLayout()->addElement(0, 0, colorScale.m_Scale);
                      }
                      // Set color scale properties
-                     setAxisProperties(*colorScale.m_Scale->axis(), valuesUnit, QCPAxis::stLogarithmic);
                      colorScale.m_AutomaticThreshold = true;
                  }
+                 static void setUnits(T &dataSeries, QCustomPlot &plot, SqpColorScale &colorScale)
+                 {
+                     dataSeries.lockRead();
+                     auto xAxisUnit = dataSeries.xAxisUnit();
+                     auto yAxisUnit = dataSeries.yAxisUnit();
+                     auto valuesUnit = dataSeries.valuesUnit();
+                     dataSeries.unlock();
+                     setAxisProperties(*plot.xAxis, xAxisUnit);
+                     setAxisProperties(*plot.yAxis, yAxisUnit, QCPAxis::stLogarithmic);
+                     setAxisProperties(*colorScale.m_Scale->axis(), valuesUnit, QCPAxis::stLogarithmic);
+                 }
              };
              /**
               */
              template <typename T>
              struct AxisHelper : public IAxisHelper {
-                 explicit AxisHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
+                 explicit AxisHelper(std::shared_ptr<T> dataSeries) : m_DataSeries{dataSeries} {}
                  void setProperties(QCustomPlot &plot, SqpColorScale &colorScale) override
                  {
-                     AxisSetter<T>::setProperties(m_DataSeries, plot, colorScale);
+                     AxisSetter<T>::setProperties(plot, colorScale);
+                 }
+                 void setUnits(QCustomPlot &plot, SqpColorScale &colorScale) override
+                 {
+                     if (m_DataSeries) {
+                         AxisSetter<T>::setUnits(*m_DataSeries, plot, colorScale);
+                     }
+                     else {
+                         qCCritical(LOG_AxisRenderingUtils()) << "Can't set units: inconsistency between the "
+                                                                 "type of data series and the type supposed";
+                     }
                  }
-                 T &m_DataSeries;
+                 std::shared_ptr<T> m_DataSeries;
              };
              } // namespace
                  }
              }
-             std::unique_ptr<IAxisHelper>
-             IAxisHelperFactory::create(std::shared_ptr<IDataSeries> dataSeries) noexcept
+             std::unique_ptr<IAxisHelper> IAxisHelperFactory::create(const Variable &variable) noexcept
              {
-                 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
-                     return std::make_unique<AxisHelper<ScalarSeries> >(*scalarSeries);
+                 }
-                 else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
-                     return std::make_unique<AxisHelper<SpectrogramSeries> >(*spectrogramSeries);
+                 }
-                 else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
-                     return std::make_unique<AxisHelper<VectorSeries> >(*vectorSeries);
+                 }
-                 else {
-                     return std::make_unique<AxisHelper<IDataSeries> >(*dataSeries);
+                 }
+                 switch (variable.type()) {
+                     case DataSeriesType::SCALAR:
+                         return std::make_unique<AxisHelper<ScalarSeries> >(
+                             std::dynamic_pointer_cast<ScalarSeries>(variable.dataSeries()));
+                     case DataSeriesType::SPECTROGRAM:
+                         return std::make_unique<AxisHelper<SpectrogramSeries> >(
+                             std::dynamic_pointer_cast<SpectrogramSeries>(variable.dataSeries()));
+                     case DataSeriesType::VECTOR:
+                         return std::make_unique<AxisHelper<VectorSeries> >(
+                             std::dynamic_pointer_cast<VectorSeries>(variable.dataSeries()));
+                     default:
+                         // Creates default helper
+                         break;
+                 }
+                 return std::make_unique<AxisHelper<IDataSeries> >(nullptr);
              }

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