GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r902:c7e7c81a51b1

Merge branch 'feature/MockSpectrogram' into develop

Alexandre Leroux -

r902:c7e7c81a51b1

parent child

Context file:

r902:c7e7c81a51b1

Collapse all files

plugins/mockplugin/src/CosinusProvider.cpp +71 -8

             #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 <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;
             /// 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,
                                                                       Unit xAxisUnit,
                                                                       Unit valuesUnit) 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, Unit xAxisUnit,
                                                               Unit valuesUnit) const override
                 {
                     return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                           xAxisUnit, valuesUnit);
                 }
+                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)
+                        : m_YAxisData{std::move(yAxisData)}, m_YAxisUnit{std::move(yAxisUnit)}
+                {
+                }
+                int componentCount() const override { return m_YAxisData.size(); }
+                std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
+                                                              std::vector<double> valuesData, Unit xAxisUnit,
+                                                              Unit valuesUnit) const override
+                {
+                    return std::make_shared<SpectrogramSeries>(std::move(xAxisData), m_YAxisData,
+                                                               std::move(valuesData), xAxisUnit, m_YAxisUnit,
+                                                               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);
+                        values[componentCount * dataIndex + i] = value;
+                    }
+                }
+                std::vector<double> m_YAxisData;
+                Unit m_YAxisUnit;
+            };
             struct VectorCosinus : public ICosinusType {
                 int componentCount() const override { return 3; }
                 std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
                                                               std::vector<double> valuesData, Unit xAxisUnit,
                                                               Unit valuesUnit) const override
                 {
                     return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(valuesData),
                                                           xAxisUnit, valuesUnit);
                 }
+                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"});
+                }
                 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 timeOnFreq = time / freq;
+                        const auto x = time / freq;
-                        xAxisData[dataIndex] = timeOnFreq;
+                        xAxisData[dataIndex] = x;
-                        // Generates all components' values
+                        // Generates values (depending on the type)
-                        // Example: for a vector, values will be : cos(x), cos(x)/2, cos(x)/3
+                        type->generateValues(x, valuesData, dataIndex);
-                        auto value = std::cos(timeOnFreq);
-                        for (auto i = 0; i < componentCount; ++i) {
-                            valuesData[componentCount * dataIndex + i] = value / (i + 1);
                         // 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),
                                               Unit{QStringLiteral("t"), true}, Unit{});
             }
             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;
             }

plugins/mockplugin/src/MockPlugin.cpp +5 0

             #include "MockPlugin.h"
             #include "CosinusProvider.h"
             #include "MockDefs.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_MockPlugin, "MockPlugin")
             namespace {
             /// Name of the data source
             const auto DATA_SOURCE_NAME = QStringLiteral("MMS");
             /// Creates the data provider relative to the plugin
             std::unique_ptr<IDataProvider> createDataProvider() noexcept
             {
                 return std::make_unique<CosinusProvider>();
             }
             std::unique_ptr<DataSourceItem> createProductItem(const QVariantHash &data,
                                                               const QUuid &dataSourceUid)
             {
                 auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, data);
                 auto productName = data.value(DataSourceItem::NAME_DATA_KEY).toString();
                 // Add action to load product from DataSourceController
                 result->addAction(std::make_unique<DataSourceItemAction>(
                     QObject::tr("Load %1 product").arg(productName),
                     [productName, dataSourceUid](DataSourceItem &item) {
                         if (auto app = sqpApp) {
                             app->dataSourceController().loadProductItem(dataSourceUid, item);
                         }
                     }));
                 return result;
             }
             /// Creates the data source item relative to the plugin
             std::unique_ptr<DataSourceItem> createDataSourceItem(const QUuid &dataSourceUid) noexcept
             {
                 // Magnetic field products
                 auto magneticFieldFolder = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
                                                                             QStringLiteral("Magnetic field"));
                 magneticFieldFolder->appendChild(
                     createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Scalar 10 Hz")},
                                        {COSINUS_TYPE_KEY, "scalar"},
                                        {COSINUS_FREQUENCY_KEY, 10.}},
                                       dataSourceUid));
                 magneticFieldFolder->appendChild(
                     createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Scalar 60 Hz")},
                                        {COSINUS_TYPE_KEY, "scalar"},
                                        {COSINUS_FREQUENCY_KEY, 60.}},
                                       dataSourceUid));
                 magneticFieldFolder->appendChild(
                     createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Scalar 100 Hz")},
                                        {COSINUS_TYPE_KEY, "scalar"},
                                        {COSINUS_FREQUENCY_KEY, 100.}},
                                       dataSourceUid));
                 magneticFieldFolder->appendChild(
                     createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Vector 10 Hz")},
                                        {COSINUS_TYPE_KEY, "vector"},
                                        {COSINUS_FREQUENCY_KEY, 10.}},
                                       dataSourceUid));
                 magneticFieldFolder->appendChild(
                     createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Vector 60 Hz")},
                                        {COSINUS_TYPE_KEY, "vector"},
                                        {COSINUS_FREQUENCY_KEY, 60.}},
                                       dataSourceUid));
                 magneticFieldFolder->appendChild(
                     createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Vector 100 Hz")},
                                        {COSINUS_TYPE_KEY, "vector"},
                                        {COSINUS_FREQUENCY_KEY, 100.}},
                                       dataSourceUid));
+                magneticFieldFolder->appendChild(
+                    createProductItem({{DataSourceItem::NAME_DATA_KEY, QStringLiteral("Spectrogram 1 Hz")},
+                                       {COSINUS_TYPE_KEY, "spectrogram"},
+                                       {COSINUS_FREQUENCY_KEY, 1.}},
+                                      dataSourceUid));
                 // Electric field products
                 auto electricFieldFolder = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
                                                                             QStringLiteral("Electric field"));
                 // Root
                 auto root = std::make_unique<DataSourceItem>(DataSourceItemType::NODE, DATA_SOURCE_NAME);
                 root->appendChild(std::move(magneticFieldFolder));
                 root->appendChild(std::move(electricFieldFolder));
                 return root;
             }
             } // namespace
             void MockPlugin::initialize()
             {
                 if (auto app = sqpApp) {
                     // Registers to the data source controller
                     auto &dataSourceController = app->dataSourceController();
                     auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
                     // Sets data source tree
                     dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem(dataSourceUid));
                     // Sets data provider
                     dataSourceController.setDataProvider(dataSourceUid, createDataProvider());
                 }
                 else {
                     qCWarning(LOG_MockPlugin()) << tr("Can't access to SciQlop application");
                 }
             }

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