GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1306:cd191f594800

Updates AxisRenderingUtils to use variable's type instead of dataseries

Alexandre Leroux -

r1306:cd191f594800

parent child

Context file:

r1306: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
+                /// Creates IPlottablesHelper according to the type of data series a variable holds
-                static std::unique_ptr<IAxisHelper> create(std::shared_ptr<IDataSeries> dataSeries) noexcept;
+                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>
+            std::unique_ptr<IAxisHelper> IAxisHelperFactory::create(const Variable &variable) noexcept
-            IAxisHelperFactory::create(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
-                if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
+                switch (variable.type()) {
-                    return std::make_unique<AxisHelper<ScalarSeries> >(*scalarSeries);
+                    case DataSeriesType::SCALAR:
+                        return std::make_unique<AxisHelper<ScalarSeries> >(
-                else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
+                            std::dynamic_pointer_cast<ScalarSeries>(variable.dataSeries()));
-                    return std::make_unique<AxisHelper<SpectrogramSeries> >(*spectrogramSeries);
+                    case DataSeriesType::SPECTROGRAM:
+                        return std::make_unique<AxisHelper<SpectrogramSeries> >(
-                else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
+                            std::dynamic_pointer_cast<SpectrogramSeries>(variable.dataSeries()));
-                    return std::make_unique<AxisHelper<VectorSeries> >(*vectorSeries);
+                    case DataSeriesType::VECTOR:
+                        return std::make_unique<AxisHelper<VectorSeries> >(
-                else {
+                            std::dynamic_pointer_cast<VectorSeries>(variable.dataSeries()));
-                    return std::make_unique<AxisHelper<IDataSeries> >(*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