GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r927:c91efb7c50ed

Adds logs to axe and plottable rendering utils

Alexandre Leroux -

r927:c91efb7c50ed

parent child

Context file:

r927:c91efb7c50ed

Collapse all files

gui/include/Visualization/AxisRenderingUtils.h +3 0

             #ifndef SCIQLOP_AXISRENDERINGUTILS_H
             #define SCIQLOP_AXISRENDERINGUTILS_H
             #include <memory>
+            #include <QtCore/QLoggingCategory>
             #include <QtCore/QString>
+            Q_DECLARE_LOGGING_CATEGORY(LOG_AxisRenderingUtils)
             class IDataSeries;
             class QCPAxis;
             class QCPColorScale;
             class QCustomPlot;
             /// Formats a data value according to the axis on which it is present
             QString formatValue(double value, const QCPAxis &axis);
             /**
              * Helper used to handle axes rendering
              */
             struct IAxisHelper {
                 virtual ~IAxisHelper() noexcept = default;
                 /// Set properties of the plot's axes and the color scale associated to plot passed as
                 /// parameters
                 /// @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, QCPColorScale &colorScale) = 0;
             };
             struct IAxisHelperFactory {
                 /// Creates IAxisHelper according to a data series
                 static std::unique_ptr<IAxisHelper> create(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             };
             #endif // SCIQLOP_AXISRENDERINGUTILS_H

gui/include/Visualization/PlottablesRenderingUtils.h +4 0

             #ifndef SCIQLOP_PLOTTABLESRENDERINGUTILS_H
             #define SCIQLOP_PLOTTABLESRENDERINGUTILS_H
             #include <Visualization/VisualizationDefs.h>
             #include <memory>
+            #include <QtCore/QLoggingCategory>
+            Q_DECLARE_LOGGING_CATEGORY(LOG_PlottablesRenderingUtils)
             class IDataSeries;
             class QCPColorScale;
             class QCustomPlot;
             /**
              * Helper used to handle plottables rendering
              */
             struct IPlottablesHelper {
                 virtual ~IPlottablesHelper() noexcept = default;
                 /// Set properties of the plottables passed as parameter
                 /// @param plottables the plottables for which to set properties
                 virtual void setProperties(PlottablesMap &plottables) = 0;
             };
             struct IPlottablesHelperFactory {
                 /// Creates IPlottablesHelper according to a data series
                 static std::unique_ptr<IPlottablesHelper>
                 create(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             };
             #endif // SCIQLOP_PLOTTABLESRENDERINGUTILS_H

gui/src/Visualization/AxisRenderingUtils.cpp +3 0

             #include "Visualization/AxisRenderingUtils.h"
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <Visualization/qcustomplot.h>
+            Q_LOGGING_CATEGORY(LOG_AxisRenderingUtils, "AxisRenderingUtils")
             namespace {
             const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
             /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
             /// non-time data
             QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
             {
                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
                     dateTicker->setDateTimeSpec(Qt::UTC);
                     return dateTicker;
                 }
                 else {
                     // default ticker
                     return QSharedPointer<QCPAxisTicker>::create();
                 }
             }
             /**
              * Sets properties of the axis passed as parameter
              * @param axis the axis to set
              * @param unit the unit to set for the axis
              * @param scaleType the scale type to set for the axis
              */
             void setAxisProperties(QCPAxis &axis, const Unit &unit,
                                    QCPAxis::ScaleType scaleType = QCPAxis::stLinear)
             {
                 // label (unit name)
                 axis.setLabel(unit.m_Name);
                 // scale type
                 axis.setScaleType(scaleType);
                 // ticker (depending on the type of unit)
                 axis.setTicker(axisTicker(unit.m_TimeUnit));
             }
             /**
              * Delegate used to set axes properties
              */
             template <typename T, typename Enabled = void>
             struct AxisSetter {
                 static void setProperties(T &, QCustomPlot &, QCPColorScale &)
                 {
                     // Default implementation does nothing
+                    qCCritical(LOG_AxisRenderingUtils()) << "Can't set axis properties: unmanaged type of data";
                 }
             };
             /**
              * Specialization of AxisSetter for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             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, QCPColorScale &)
                 {
                     dataSeries.lockRead();
                     auto xAxisUnit = dataSeries.xAxisUnit();
                     auto valuesUnit = dataSeries.valuesUnit();
                     dataSeries.unlock();
                     setAxisProperties(*plot.xAxis, xAxisUnit);
                     setAxisProperties(*plot.yAxis, valuesUnit);
                 }
             };
             /**
              * Specialization of AxisSetter for spectrograms
              * @sa SpectrogramSeries
              */
             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, QCPColorScale &colorScale)
                 {
                     dataSeries.lockRead();
                     auto xAxisUnit = dataSeries.xAxisUnit();
                     /// @todo ALX: use iterators here
                     auto yAxisUnit = dataSeries.yAxis().unit();
                     auto valuesUnit = dataSeries.valuesUnit();
                     dataSeries.unlock();
                     setAxisProperties(*plot.xAxis, xAxisUnit);
                     setAxisProperties(*plot.yAxis, yAxisUnit);
                     // Displays color scale in plot
                     plot.plotLayout()->insertRow(0);
                     plot.plotLayout()->addElement(0, 0, &colorScale);
                     colorScale.setType(QCPAxis::atTop);
                     colorScale.setMinimumMargins(QMargins{0, 0, 0, 0});
                     // Aligns color scale with axes
                     auto marginGroups = plot.axisRect()->marginGroups();
                     for (auto it = marginGroups.begin(), end = marginGroups.end(); it != end; ++it) {
                         colorScale.setMarginGroup(it.key(), it.value());
                     }
                     // Set color scale properties
                     colorScale.setLabel(valuesUnit.m_Name);
                     colorScale.setDataScaleType(QCPAxis::stLogarithmic); // Logarithmic scale
                 }
             };
             /**
              * Default implementation of IAxisHelper, which takes data series to set axes properties
              * @tparam T the data series' type
              */
             template <typename T>
             struct AxisHelper : public IAxisHelper {
                 explicit AxisHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
                 void setProperties(QCustomPlot &plot, QCPColorScale &colorScale) override
                 {
                     AxisSetter<T>::setProperties(m_DataSeries, plot, colorScale);
                 }
                 T &m_DataSeries;
             };
             } // namespace
             QString formatValue(double value, const QCPAxis &axis)
             {
                 // If the axis is a time axis, formats the value as a date
                 if (auto axisTicker = qSharedPointerDynamicCast<QCPAxisTickerDateTime>(axis.ticker())) {
                     return DateUtils::dateTime(value, axisTicker->dateTimeSpec()).toString(DATETIME_FORMAT);
                 }
                 else {
                     return QString::number(value);
                 }
             }
             std::unique_ptr<IAxisHelper>
             IAxisHelperFactory::create(std::shared_ptr<IDataSeries> dataSeries) 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);
                 }
             }

gui/src/Visualization/PlottablesRenderingUtils.cpp +7 0

             #include "Visualization/PlottablesRenderingUtils.h"
             #include <Common/ColorUtils.h>
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <Visualization/qcustomplot.h>
+            Q_LOGGING_CATEGORY(LOG_PlottablesRenderingUtils, "PlottablesRenderingUtils")
             namespace {
             /// Default gradient used for colormap
             const auto DEFAULT_COLORMAP_GRADIENT = QCPColorGradient::gpJet;
             /**
              * Delegate used to set plottables properties
              */
             template <typename T, typename Enabled = void>
             struct PlottablesSetter {
                 static void setProperties(T &, PlottablesMap &)
                 {
                     // Default implementation does nothing
+                    qCCritical(LOG_PlottablesRenderingUtils())
+                        << "Can't set plottables properties: unmanaged type of data";
                 }
             };
             /**
              * Specialization of PlottablesSetter for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesSetter<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, PlottablesMap &plottables)
                 {
                     // Gets the number of components of the data series
                     dataSeries.lockRead();
                     auto componentCount = dataSeries.valuesData()->componentCount();
                     dataSeries.unlock();
                     // Generates colors for each component
                     auto colors = ColorUtils::colors(Qt::blue, Qt::red, componentCount);
                     // For each component of the data series, creates a QCPGraph to add to the plot
                     for (auto i = 0; i < componentCount; ++i) {
                         auto graph = plottables.at(i);
                         graph->setPen(QPen{colors.at(i)});
                     }
                 }
             };
             /**
              * Specialization of PlottablesSetter for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesSetter<T,
                                     typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
                 static void setProperties(T &, PlottablesMap &plottables)
                 {
                     // Checks that for a spectrogram there is only one plottable, that is a colormap
                     if (plottables.size() != 1) {
                         return;
                     }
                     if (auto colormap = dynamic_cast<QCPColorMap *>(plottables.begin()->second)) {
                         colormap->setInterpolate(false); // No value interpolation
                         colormap->setTightBoundary(true);
                         // Finds color scale in the colormap's plot to associate with it
                         auto plot = colormap->parentPlot();
                         auto plotElements = plot->plotLayout()->elements(false);
                         for (auto plotElement : plotElements) {
                             if (auto colorScale = dynamic_cast<QCPColorScale *>(plotElement)) {
                                 colormap->setColorScale(colorScale);
                             }
                         }
                         // Sets gradient used for color scale
                         colormap->setGradient(DEFAULT_COLORMAP_GRADIENT);
                         colormap->rescaleDataRange();
                     }
+                    else {
+                        qCCritical(LOG_PlottablesRenderingUtils()) << "Can't get colormap of the spectrogram";
+                    }
                 }
             };
             /**
              * Default implementation of IPlottablesHelper, which takes data series to set plottables properties
              * @tparam T the data series' type
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper {
                 explicit PlottablesHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
                 void setProperties(PlottablesMap &plottables) override
                 {
                     PlottablesSetter<T>::setProperties(m_DataSeries, plottables);
                 }
                 T &m_DataSeries;
             };
             } // namespace
             std::unique_ptr<IPlottablesHelper>
             IPlottablesHelperFactory::create(std::shared_ptr<IDataSeries> dataSeries) 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);
                 }
             }

General Comments 1

trabillard

|

Auto status change to "Under Review"

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