HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1350:09a8c8a01145

Ported Mock plugin to new IDataProvider interface compatible with...

jeandet -

r1350:09a8c8a01145

parent child

Context file:

r1350:09a8c8a01145

core +1 -1

	@@ -1,1 +1,1
	1	Subproject commit de55e7be90966d1efbd34a10df9a3231c50e245b		1	Subproject commit c08d1b8ad2976824def52cf0fca26a72b1069356

gui/src/DragAndDrop/DragDropGuiController.cpp +1 -1

                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variables(
-                        mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                        Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                     if (variables.size() == 1) {

gui/src/SqpApplication.cpp +6 -7

             public:
                 SqpApplicationPrivate()
                         : m_VariableController{std::make_shared<VariableController2>()},
-                          m_VariableModel{m_VariableController},
                           m_PlotInterractionMode(SqpApplication::PlotsInteractionMode::None),
                           m_PlotCursorMode(SqpApplication::PlotsCursorMode::NoCursor)
                 {
                     // VariableController <-> DataSourceController
                     connect(&m_DataSourceController,
-                            SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
+                            &DataSourceController::createVariable,[](const QString &variableName,
-                                                             std::shared_ptr<IDataProvider>)),
+                            const QVariantHash &variableMetadata,
-                            m_VariableController.get(),
+                            std::shared_ptr<IDataProvider> variableProvider)
-                            SLOT(createVariable(const QString &, const QVariantHash &,
-                                                std::shared_ptr<IDataProvider>)));
+                        sqpApp->variableController().createVariable(variableName,variableMetadata,variableProvider,sqpApp->timeController().dateTime());
+                    });
             //        connect(m_VariableController->variableModel(), &VariableModel::requestVariable,
             //                m_DataSourceController.get(), &DataSourceController::requestVariable);
                 NetworkController m_NetworkController;
                 VisualizationController m_VisualizationController;
                 CatalogueController m_CatalogueController;
-                VariableModel2 m_VariableModel;
                 QThread m_DataSourceControllerThread;
                 QThread m_NetworkControllerThread;

gui/src/Variable/VariableInspectorWidget.cpp +13 -3

             #include <Variable/VariableInspectorWidget.h>
             #include <Variable/VariableMenuHeaderWidget.h>
             #include <Variable/VariableModel2.h>
+            #include <DataSource/DataSourceController.h>
             #include <ui_VariableInspectorWidget.h>
                 //    auto sortFilterModel = new QSortFilterProxyModel{this};
                 //    sortFilterModel->setSourceModel(sqpApp->variableController().variableModel());
-                m_model = new VariableModel2(sqpApp->variableControllerOwner());
+                m_model = new VariableModel2();
                 ui->tableView->setModel(m_model);
+                connect(m_model, &VariableModel2::createVariable,
+                        [](const QVariantHash &productData)
+                {
+                    sqpApp->dataSourceController().requestVariable(productData);
+                });
+                auto vc = &(sqpApp->variableController());
+                connect(vc, &VariableController2::variableAdded, m_model, &VariableModel2::variableAdded);
+                connect(vc, &VariableController2::variableDeleted, m_model, &VariableModel2::variableDeleted);
+                connect(m_model, &VariableModel2::asyncChangeRange, vc, &VariableController2::asyncChangeRange);
                 // Adds extra signal/slot between view and model, so the view can be updated instantly when
                 // there is a change of data in the model
-                connect(m_model, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this,
+                //connect(m_model, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this,
-                        SLOT(refresh()));
+                //        SLOT(refresh()));
                 //ui->tableView->setSelectionModel(sqpApp->variableController().variableSelectionModel());
                 ui->tableView->setItemDelegateForColumn(0, m_ProgressBarItemDelegate);

gui/src/Visualization/VisualizationTabWidget.cpp +1 -1

                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variables(
-                        mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                        Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                     impl->dropVariables(variables, index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {

gui/src/Visualization/VisualizationZoneWidget.cpp +3 -3

                     if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                         auto variables = sqpApp->variableController().variables(
-                            mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                            Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                         if (variables.size() != 1) {
                             return false;
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variables(
-                        mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                        Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                     impl->dropVariables(variables, index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
                 if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variables(
-                        mimeData->data(MIME_TYPE_VARIABLE_LIST));
+                        Variable::variablesIDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
                     for (const auto &var : variables) {
                         graphWidget->addVariable(var, graphWidget->graphRange());
                     }

plugins/mockplugin/include/CosinusProvider.h +4 0

                 void requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters) override;
+                virtual IDataSeries* getData(const DataProviderParameters &parameters) override;
                 /// @sa IDataProvider::requestDataAborting(). The current impl isn't thread safe.
                 void requestDataAborting(QUuid acqIdentifier) override;
                 std::shared_ptr<IDataSeries>
                 retrieveData(QUuid acqIdentifier, const DateTimeRange &dataRangeRequested, const QVariantHash &data);
+                IDataSeries* _generate(const DateTimeRange &range, const QVariantHash &metaData);
                 QHash<QUuid, bool> m_VariableToEnableProvider;
             };

plugins/mockplugin/src/CosinusProvider.cpp +52 -11

             struct ICosinusType {
                 virtual ~ICosinusType() = default;
                 /// @return the number of components generated for the type
-                virtual int componentCount() const = 0;
+                virtual std::size_t componentCount() const = 0;
                 /// @return the data series created for the type
-                virtual std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
+                virtual 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
             };
             struct ScalarCosinus : public ICosinusType {
-                int componentCount() const override { return 1; }
+                std::size_t componentCount() const override { return 1; }
-                std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
+                IDataSeries* createDataSeries(std::vector<double> xAxisData,
                                                               std::vector<double> valuesData) const override
                 {
-                    return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
+                    return new ScalarSeries(std::move(xAxisData), std::move(valuesData),
                                                           Unit{QStringLiteral("t"), true}, Unit{});
                 }
                 {
                 }
-                int componentCount() const override { return m_YAxisData.size(); }
+                std::size_t componentCount() const override { return m_YAxisData.size(); }
-                std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
+                IDataSeries* createDataSeries(std::vector<double> xAxisData,
                                                               std::vector<double> valuesData) const override
                 {
-                    return std::make_shared<SpectrogramSeries>(
+                    return new SpectrogramSeries(
                         std::move(xAxisData), m_YAxisData, std::move(valuesData),
                         Unit{QStringLiteral("t"), true}, m_YAxisUnit, m_ValuesUnit);
                 }
             };
             struct VectorCosinus : public ICosinusType {
-                int componentCount() const override { return 3; }
+                std::size_t componentCount() const override { return 3; }
-                std::shared_ptr<IDataSeries> createDataSeries(std::vector<double> xAxisData,
+                IDataSeries* createDataSeries(std::vector<double> xAxisData,
                                                               std::vector<double> valuesData) const override
                 {
-                    return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(valuesData),
+                    return new VectorSeries(std::move(xAxisData), std::move(valuesData),
                                                           Unit{QStringLiteral("t"), true}, Unit{});
                 }
                     // We can close progression beacause all data has been retrieved
                     emit dataProvidedProgress(acqIdentifier, 100);
                 }
+                return std::shared_ptr<IDataSeries>(type->createDataSeries(std::move(xAxisData), std::move(valuesData)));
+            }
+            IDataSeries *CosinusProvider::_generate(const DateTimeRange &range, const QVariantHash &metaData)
+            {
+                auto dataIndex = 0;
+                // Retrieves cosinus type
+                auto typeVariant = metaData.value(COSINUS_TYPE_KEY, COSINUS_TYPE_DEFAULT_VALUE);
+                auto type = cosinusType(typeVariant.toString());
+                auto freqVariant = metaData.value(COSINUS_FREQUENCY_KEY, COSINUS_FREQUENCY_DEFAULT_VALUE);
+                double freq = freqVariant.toDouble();
+                double start = std::ceil(range.m_TStart * freq);
+                double end = std::floor(range.m_TEnd * freq);
+                if (end < start) {
+                    std::swap(start, end);
+                }
+                std::size_t dataCount = static_cast<std::size_t>(end - start + 1);
+                std::size_t 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)
+                {
+                        const auto x = time / freq;
+                        xAxisData[dataIndex] = x;
+                        // Generates values (depending on the type)
+                        type->generateValues(x, valuesData, dataIndex);
+                }
                 return type->createDataSeries(std::move(xAxisData), std::move(valuesData));
             }
                 }
             }
+            IDataSeries* CosinusProvider::getData(const DataProviderParameters &parameters)
+            {
+                return _generate(parameters.m_Times.front(),parameters.m_Data);
+            }
             void CosinusProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << acqIdentifier

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