HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r922:e65d7f08d776

Introduces NaN and zero values in data of the mock spectrogram...

Alexandre Leroux -

r922:e65d7f08d776

parent child

Context file:

r922:e65d7f08d776

Collapse all files

gui/src/Visualization/VisualizationGraphHelper.cpp +10 -1

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <Variable/Variable.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             namespace {
             class SqpDataContainer : public QCPGraphDataContainer {
             public:
                 void appendGraphData(const QCPGraphData &data) { mData.append(data); }
             };
             /**
              * Struct used to create plottables, depending on the type of the data series from which to create
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't create plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesCreator {
                 static PlottablesMap createPlottables(T &, QCustomPlot &)
                 {
                     qCCritical(LOG_DataSeries())
                         << QObject::tr("Can't create plottables: unmanaged data series type");
                     return {};
                 }
             };
             /**
              * 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 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) {
                         auto graph = plot.addGraph();
                         result.insert({i, graph});
                     }
                     plot.replot();
                     return result;
                 }
             };
             /**
              * Specialization of PlottablesCreator for spectrograms
              * @sa SpectrogramSeries
              */
             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)
                 {
                     PlottablesMap result{};
                     result.insert({0, new QCPColorMap{plot.xAxis, plot.yAxis}});
                     plot.replot();
                     return result;
                 }
             };
             /**
              * Struct used to update plottables, depending on the type of the data series from which to update
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't update plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesUpdater {
                 static void setPlotYAxisRange(T &, const SqpRange &, QCustomPlot &)
                 {
                     qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't set plot y-axis range: unmanaged data series type");
                 }
                 static void updatePlottables(T &, PlottablesMap &, const SqpRange &, bool)
                 {
                     qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't update plottables: unmanaged data series type");
                 }
             };
             /**
              * Specialization of PlottablesUpdater for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             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)
                 {
                     // For each plottable to update, resets its data
                     std::map<int, QSharedPointer<SqpDataContainer> > dataContainers{};
                     for (const auto &plottable : plottables) {
                         if (auto graph = dynamic_cast<QCPGraph *>(plottable.second)) {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             graph->setData(dataContainer);
                             dataContainers.insert({plottable.first, dataContainer});
                         }
                     }
                     dataSeries.lockRead();
                     // - Gets the data of the series included in the current range
                     // - Updates each plottable by adding, for each data item, a point that takes x-axis data
                     // and value data. The correct value is retrieved according to the index of the component
                     auto subDataIts = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);
                     for (auto it = subDataIts.first; it != subDataIts.second; ++it) {
                         for (const auto &dataContainer : dataContainers) {
                             auto componentIndex = dataContainer.first;
                             dataContainer.second->appendGraphData(
                                 QCPGraphData(it->x(), it->value(componentIndex)));
                         }
                     }
                     dataSeries.unlock();
                     if (!plottables.empty()) {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes) {
                             plot->rescaleAxes();
                         }
                         plot->replot();
                     }
                 }
             };
             /**
              * Specialization of PlottablesUpdater for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesUpdater<T,
                                      typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
                 static void setPlotYAxisRange(T &dataSeries, const SqpRange &xAxisRange, QCustomPlot &plot)
                 {
                     double min, max;
                     /// @todo ALX: use iterators here
                     std::tie(min, max) = dataSeries.yAxis().bounds();
                     if (!std::isnan(min) && !std::isnan(max)) {
                         plot.yAxis->setRange(QCPRange{min, max});
                     }
                 }
                 static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const SqpRange &range,
                                              bool rescaleAxes)
                 {
                     if (plottables.empty()) {
                         qCDebug(LOG_VisualizationGraphHelper())
                             << QObject::tr("Can't update spectrogram: no colormap has been associated");
                         return;
                     }
                     // Gets the colormap to update (normally there is only one colormap)
                     Q_ASSERT(plottables.size() == 1);
                     auto colormap = dynamic_cast<QCPColorMap *>(plottables.at(0));
                     Q_ASSERT(colormap != nullptr);
                     dataSeries.lockRead();
                     auto its = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);
                     /// @todo ALX: use iterators here
                     auto yAxis = dataSeries.yAxis();
                     // Gets properties of x-axis and y-axis to set size and range of the colormap
                     auto nbX = std::distance(its.first, its.second);
                     auto xMin = nbX != 0 ? its.first->x() : 0.;
                     auto xMax = nbX != 0 ? (its.second - 1)->x() : 0.;
                     auto nbY = yAxis.size();
                     auto yMin = 0., yMax = 0.;
                     if (nbY != 0) {
                         std::tie(yMin, yMax) = yAxis.bounds();
                     }
                     colormap->data()->setSize(nbX, nbY);
                     colormap->data()->setRange(QCPRange{xMin, xMax}, QCPRange{yMin, yMax});
                     // Sets values
                     auto xIndex = 0;
                     for (auto it = its.first; it != its.second; ++it, ++xIndex) {
                         for (auto yIndex = 0; yIndex < nbY; ++yIndex) {
-                            colormap->data()->setCell(xIndex, yIndex, it->value(yIndex));
+                            auto value = it->value(yIndex);
+                            colormap->data()->setCell(xIndex, yIndex, value);
+                            // Processing spectrogram data for display in QCustomPlot
+                            /// For the moment, we just make the NaN values to be transparent in the colormap
+                            /// @todo ALX: complete treatments (mesh generation, etc.)
+                            if (std::isnan(value)) {
+                                colormap->data()->setAlpha(xIndex, yIndex, 0);
+                            }
                         }
                     }
                     dataSeries.unlock();
                     // Rescales axes
                     auto plot = colormap->parentPlot();
                     if (rescaleAxes) {
                         plot->rescaleAxes();
                     }
                     plot->replot();
                 }
             };
             /**
              * Helper used to create/update plottables
              */
             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;
             };
             /**
              * Default implementation of IPlottablesHelper, which takes data series to create/update plottables
              * @tparam T the data series' type
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper {
                 explicit PlottablesHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
                 PlottablesMap create(QCustomPlot &plot) const override
                 {
                     return PlottablesCreator<T>::createPlottables(m_DataSeries, plot);
                 }
                 void update(PlottablesMap &plottables, const SqpRange &range, bool rescaleAxes) const override
                 {
                     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;
             };
             /// Creates IPlottablesHelper according to a data series
             std::unique_ptr<IPlottablesHelper> createHelper(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);
                 }
             }
             } // namespace
             PlottablesMap VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
                                                            QCustomPlot &plot) noexcept
             {
                 if (variable) {
                     auto helper = createHelper(variable->dataSeries());
                     auto plottables = helper->create(plot);
                     return plottables;
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                     return PlottablesMap{};
                 }
             }
             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)
             {
                 auto helper = createHelper(dataSeries);
                 helper->update(plottables, dateTime);
             }

plugins/mockplugin/src/CosinusProvider.cpp +21 -2

             #include "CosinusProvider.h"
             #include "MockDefs.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <cmath>
+            #include <set>
             #include <QFuture>
             #include <QThread>
             #include <QtConcurrent/QtConcurrent>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
             namespace {
             /// Number of bands generated for a spectrogram
             const auto SPECTROGRAM_NUMBER_BANDS = 30;
+            /// Bands for which to generate NaN values for a spectrogram
+            const auto SPECTROGRAM_NAN_BANDS = std::set<int>{1, 3, 10, 20};
+            /// Bands for which to generate zeros for a spectrogram
+            const auto SPECTROGRAM_ZERO_BANDS = std::set<int>{2, 15, 19, 29};
             /// Abstract cosinus type
             struct ICosinusType {
                 virtual ~ICosinusType() = default;
                 /// @return the number of components generated for the type
                 virtual int componentCount() const = 0;
                 /// @return the data series created for the type
                 virtual std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
                                                                       std::vector<double> valuesData) const = 0;
                 /// Generates values (one value per component)
                 /// @param x the x-axis data used to generate values
                 /// @param values the vector in which to insert the generated values
                 /// @param dataIndex the index of insertion of the generated values
                 ///
                 virtual void generateValues(double x, std::vector<double> &values, int dataIndex) const = 0;
             };
             struct ScalarCosinus : public ICosinusType {
                 int componentCount() const override { return 1; }
                 std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
                                                               std::vector<double> valuesData) const override
                 {
                     return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                           Unit{QStringLiteral("t"), true}, Unit{});
                 }
                 void generateValues(double x, std::vector<double> &values, int dataIndex) const override
                 {
                     values[dataIndex] = std::cos(x);
                 }
             };
             struct SpectrogramCosinus : public ICosinusType {
                 /// Ctor with y-axis
                 explicit SpectrogramCosinus(std::vector<double> yAxisData, Unit yAxisUnit, Unit valuesUnit)
                         : m_YAxisData{std::move(yAxisData)},
                           m_YAxisUnit{std::move(yAxisUnit)},
                           m_ValuesUnit{std::move(valuesUnit)}
                 {
                 }
                 int componentCount() const override { return m_YAxisData.size(); }
                 std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
                                                               std::vector<double> valuesData) const override
                 {
                     return std::make_shared<SpectrogramSeries>(
                         std::move(xAxisData), m_YAxisData, std::move(valuesData),
                         Unit{QStringLiteral("t"), true}, m_YAxisUnit, m_ValuesUnit);
                 }
                 void generateValues(double x, std::vector<double> &values, int dataIndex) const override
                 {
                     auto componentCount = this->componentCount();
                     for (int i = 0; i < componentCount; ++i) {
                         auto y = m_YAxisData[i];
-                        auto r = 3 * std::sqrt(x * x + y * y) + 1e-2;
-                        auto value = 2 * x * (std::cos(r + 2) / r - std::sin(r + 2) / r);
+                        double value;
+                        if (SPECTROGRAM_ZERO_BANDS.find(y) != SPECTROGRAM_ZERO_BANDS.end()) {
+                            value = 0.;
+                        }
+                        else if (SPECTROGRAM_NAN_BANDS.find(y) != SPECTROGRAM_NAN_BANDS.end()) {
+                            value = std::numeric_limits<double>::quiet_NaN();
+                        }
+                        else {
+                            // Generates value for non NaN/zero bands
+                            auto r = 3 * std::sqrt(x * x + y * y) + 1e-2;
+                            value = 2 * x * (std::cos(r + 2) / r - std::sin(r + 2) / r);
+                        }
                         values[componentCount * dataIndex + i] = value;
                     }
                 }
                 std::vector<double> m_YAxisData;
                 Unit m_YAxisUnit;
                 Unit m_ValuesUnit;
             };
             struct VectorCosinus : public ICosinusType {
                 int componentCount() const override { return 3; }
                 std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
                                                               std::vector<double> valuesData) const override
                 {
                     return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(valuesData),
                                                           Unit{QStringLiteral("t"), true}, Unit{});
                 }
                 void generateValues(double x, std::vector<double> &values, int dataIndex) const override
                 {
                     // Generates value for each component: cos(x), cos(x)/2, cos(x)/3
                     auto xValue = std::cos(x);
                     auto componentCount = this->componentCount();
                     for (auto i = 0; i < componentCount; ++i) {
                         values[componentCount * dataIndex + i] = xValue / (i + 1);
                     }
                 }
             };
             /// Converts string to cosinus type
             /// @return the cosinus type if the string could be converted, nullptr otherwise
             std::unique_ptr<ICosinusType> cosinusType(const QString &type) noexcept
             {
                 if (type.compare(QStringLiteral("scalar"), Qt::CaseInsensitive) == 0) {
                     return std::make_unique<ScalarCosinus>();
                 }
                 else if (type.compare(QStringLiteral("spectrogram"), Qt::CaseInsensitive) == 0) {
                     // Generates default y-axis data for spectrogram [0., 1., 2., ...]
                     std::vector<double> yAxisData(SPECTROGRAM_NUMBER_BANDS);
                     std::iota(yAxisData.begin(), yAxisData.end(), 0.);
                     return std::make_unique<SpectrogramCosinus>(std::move(yAxisData), Unit{"eV"},
                                                                 Unit{"eV/(cm^2-s-sr-eV)"});
                 }
                 else if (type.compare(QStringLiteral("vector"), Qt::CaseInsensitive) == 0) {
                     return std::make_unique<VectorCosinus>();
                 }
                 else {
                     return nullptr;
                 }
             }
             } // namespace
             std::shared_ptr<IDataProvider> CosinusProvider::clone() const
             {
                 // No copy is made in clone
                 return std::make_shared<CosinusProvider>();
             }
             std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
                                                                        const SqpRange &dataRangeRequested,
                                                                        const QVariantHash &data)
             {
                 // TODO: Add Mutex
                 auto dataIndex = 0;
                 // Retrieves cosinus type
                 auto typeVariant = data.value(COSINUS_TYPE_KEY, COSINUS_TYPE_DEFAULT_VALUE);
                 if (!typeVariant.canConvert<QString>()) {
                     qCCritical(LOG_CosinusProvider()) << tr("Can't retrieve data: invalid type");
                     return nullptr;
                 }
                 auto type = cosinusType(typeVariant.toString());
                 if (!type) {
                     qCCritical(LOG_CosinusProvider()) << tr("Can't retrieve data: unknown type");
                     return nullptr;
                 }
                 // Retrieves frequency
                 auto freqVariant = data.value(COSINUS_FREQUENCY_KEY, COSINUS_FREQUENCY_DEFAULT_VALUE);
                 if (!freqVariant.canConvert<double>()) {
                     qCCritical(LOG_CosinusProvider()) << tr("Can't retrieve data: invalid frequency");
                     return nullptr;
                 }
                 // Gets the timerange from the parameters
                 double freq = freqVariant.toDouble();
                 double start = std::ceil(dataRangeRequested.m_TStart * freq);
                 double end = std::floor(dataRangeRequested.m_TEnd * freq);
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second, end value is
                 // included)
                 auto dataCount = end - start + 1;
                 // Number of components (depending on the cosinus type)
                 auto componentCount = type->componentCount();
                 auto xAxisData = std::vector<double>{};
                 xAxisData.resize(dataCount);
                 auto valuesData = std::vector<double>{};
                 valuesData.resize(dataCount * componentCount);
                 int progress = 0;
                 auto progressEnd = dataCount;
                 for (auto time = start; time <= end; ++time, ++dataIndex) {
                     auto it = m_VariableToEnableProvider.find(acqIdentifier);
                     if (it != m_VariableToEnableProvider.end() && it.value()) {
                         const auto x = time / freq;
                         xAxisData[dataIndex] = x;
                         // Generates values (depending on the type)
                         type->generateValues(x, valuesData, dataIndex);
                         // progression
                         int currentProgress = (time - start) * 100.0 / progressEnd;
                         if (currentProgress != progress) {
                             progress = currentProgress;
                             emit dataProvidedProgress(acqIdentifier, progress);
                             qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::retrieveData"
                                                            << QThread::currentThread()->objectName()
                                                            << progress;
                             // NOTE: Try to use multithread if possible
                         }
                     }
                     else {
                         if (!it.value()) {
                             qCDebug(LOG_CosinusProvider())
                                 << "CosinusProvider::retrieveData: ARRET De l'acquisition detecté"
                                 << end - time;
                         }
                     }
                 }
                 if (progress != 100) {
                     // We can close progression beacause all data has been retrieved
                     emit dataProvidedProgress(acqIdentifier, 100);
                 }
                 return type->createDataSeries(std::move(xAxisData), std::move(valuesData));
             }
             void CosinusProvider::requestDataLoading(QUuid acqIdentifier,
                                                      const DataProviderParameters &parameters)
             {
                 // TODO: Add Mutex
                 m_VariableToEnableProvider[acqIdentifier] = true;
                 qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::requestDataLoading"
                                                << QThread::currentThread()->objectName();
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 for (const auto &dateTime : qAsConst(times)) {
                     if (m_VariableToEnableProvider[acqIdentifier]) {
                         auto scalarSeries = this->retrieveData(acqIdentifier, dateTime, parameters.m_Data);
                         emit dataProvided(acqIdentifier, scalarSeries, dateTime);
                     }
                 }
             }
             void CosinusProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << acqIdentifier
                                                << QThread::currentThread()->objectName();
                 auto it = m_VariableToEnableProvider.find(acqIdentifier);
                 if (it != m_VariableToEnableProvider.end()) {
                     it.value() = false;
                 }
                 else {
                     qCDebug(LOG_CosinusProvider())
                         << tr("Aborting progression of inexistant identifier detected !!!");
                 }
             }
             std::shared_ptr<IDataSeries> CosinusProvider::provideDataSeries(const SqpRange &dataRangeRequested,
                                                                             const QVariantHash &data)
             {
                 auto uid = QUuid::createUuid();
                 m_VariableToEnableProvider[uid] = true;
                 auto dataSeries = this->retrieveData(uid, dataRangeRequested, data);
                 m_VariableToEnableProvider.remove(uid);
                 return dataSeries;
             }

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