##// END OF EJS Templates
HG_REPOSITORIES » LPP » SciQLOP_Repos » SciQLop
RSS
Ported MockPlugin to new Variable2 impl and added dummy python plugin...
jeandet -
r1423:31110df2feb2
parent child
Show More
Side by Side Unified
Context file:
r1423:31110df2feb2 Loading diff...:
Show file before | Show file after | Hide comments
@@ -0,0 +1,26
1 include_directories(include)
2 FILE (GLOB_RECURSE python_providers
3 include/*.h
4 src/*.cpp
5 resources/*.qrc
6 )
7
8 add_definitions(-DQT_PLUGIN)
9 add_definitions(-DSCIQLOP_PLUGIN_JSON_FILE_PATH="${CMAKE_CURRENT_SOURCE_DIR}/resources/python_providers.json")
10 if(NOT BUILD_SHARED_LIBS)
11 add_definitions(-DQT_STATICPLUGIN)
12 endif()
13
14 add_library(python_providers ${python_providers})
15 SET_TARGET_PROPERTIES(python_providers PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
16
17 target_link_libraries(python_providers PUBLIC sciqlopgui)
18 target_link_libraries(python_providers PRIVATE pybind11::embed)
19 ADD_DEFINITIONS(-DQT_NO_KEYWORDS)
20 install(TARGETS python_providers
21 ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}/SciQlop
22 LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/SciQlop
23 RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
24
25 include(sciqlop_tests)
26
Show file before | Show file after | Hide comments
@@ -0,0 +1,25
1 #ifndef PYTHON_PROVIDERS_H
2 #define PYTHON_PROVIDERS_H
3
4 #include <Plugin/IPlugin.h>
5
6
7 #include <memory>
8
9 #ifndef SCIQLOP_PLUGIN_JSON_FILE_PATH
10 #define SCIQLOP_PLUGIN_JSON_FILE_PATH "python_providers.json"
11 #endif
12
13 class DataSourceItem;
14
15 class PythonProviders : public QObject, public IPlugin
16 {
17 Q_OBJECT
18 Q_INTERFACES(IPlugin)
19 Q_PLUGIN_METADATA(IID "sciqlop.plugin.IPlugin" FILE SCIQLOP_PLUGIN_JSON_FILE_PATH)
20 public:
21 /// @sa IPlugin::initialize()
22 void initialize() override;
23 };
24
25 #endif // PYTHON_PROVIDERS_H
Show file before | Show file after | Hide comments
@@ -0,0 +1,3
1 {
2 "name" : "python_providers"
3 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,9
1 #include "python_providers.h"
2 #include <pybind11/embed.h>
3 namespace py = pybind11;
4
5 void PythonProviders::initialize()
6 {
7 py::scoped_interpreter guard {};
8 py::print("Hello, World!");
9 }
Show file before | Show file after | Hide comments
@@ -15,7 +15,8 if(NOT BUILD_SHARED_LIBS)
15 15 add_definitions(-DQT_STATICPLUGIN)
16 16 if(BUILD_PLUGINS)
17 17 target_link_libraries(sciqlopapp mockplugin)
18 target_link_libraries(sciqlopapp amdaplugin)
18 #target_link_libraries(sciqlopapp amdaplugin)
19 target_link_libraries(sciqlopapp python_providers)
19 20 endif()
20 21 endif()
21 22
Show file before | Show file after | Hide comments
@@ -46,8 +46,9 int main(int argc, char* argv[])
46 46 #ifdef QT_STATICPLUGIN
47 47 #ifndef SQP_NO_PLUGINS
48 48 Q_IMPORT_PLUGIN(MockPlugin)
49 Q_IMPORT_PLUGIN(AmdaPlugin)
50 Q_INIT_RESOURCE(amdaresources);
49 Q_IMPORT_PLUGIN(PythonProviders)
50 // Q_IMPORT_PLUGIN(AmdaPlugin)
51 // Q_INIT_RESOURCE(amdaresources);
51 52 #endif
52 53 #endif
53 54 Q_INIT_RESOURCE(sqpguiresources);
Show file before | Show file after | Hide comments
@@ -304,12 +304,12 MainWindow::MainWindow(QWidget* parent)
304 304
305 305 // Visualization
306 306 connect(&sqpApp->visualizationController(),
307 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), m_Ui->view,
308 SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable>)));
307 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable2>)), m_Ui->view,
308 SLOT(onVariableAboutToBeDeleted(std::shared_ptr<Variable2>)));
309 309
310 310 connect(&sqpApp->visualizationController(),
311 SIGNAL(rangeChanged(std::shared_ptr<Variable>, const DateTimeRange&)), m_Ui->view,
312 SLOT(onRangeChanged(std::shared_ptr<Variable>, const DateTimeRange&)));
311 SIGNAL(rangeChanged(std::shared_ptr<Variable2>, const DateTimeRange&)), m_Ui->view,
312 SLOT(onRangeChanged(std::shared_ptr<Variable2>, const DateTimeRange&)));
313 313
314 314 // Widgets / widgets connections
315 315
Show file before | Show file after | Hide comments
@@ -1,1 +1,1
1 Subproject commit cc26524fb5d10feca3820e6921c9cd3cfb1a3591
1 Subproject commit 00ce7df31d3e11df8a418988c601247f6dc64d13
Show file before | Show file after | Hide comments
@@ -11,7 +11,7
11 11
12 12 Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationTabWidget)
13 13
14 class Variable;
14 class Variable2;
15 15 class VisualizationZoneWidget;
16 16
17 17 namespace Ui
Show file before | Show file after | Hide comments
@@ -120,8 +120,11 struct PlottablesUpdater<T, typename std::enable_if_t<std::is_base_of<ScalarTime
120 120 auto minValue = 0., maxValue = 0.;
121 121 if (auto serie = dynamic_cast<ScalarTimeSerie*>(&dataSeries))
122 122 {
123 maxValue = (*std::max_element(std::begin(*serie), std::end(*serie))).v();
124 minValue = (*std::min_element(std::begin(*serie), std::end(*serie))).v();
123 if (serie->size())
124 {
125 maxValue = (*std::max_element(std::begin(*serie), std::end(*serie))).v();
126 minValue = (*std::min_element(std::begin(*serie), std::end(*serie))).v();
127 }
125 128 }
126 129 plot.yAxis->setRange(QCPRange { minValue, maxValue });
127 130 }
Show file before | Show file after | Hide comments
@@ -1,3 +1,4
1 1 add_subdirectory(mockplugin)
2 add_subdirectory(amda)
3 add_subdirectory(generic_ws)
2 add_subdirectory(python_providers)
3 #add_subdirectory(amda)
4 #add_subdirectory(generic_ws)
Show file before | Show file after | Hide comments
@@ -17,14 +17,14 class QNetworkRequest;
17 17 /**
18 18 * @brief The AmdaProvider class is an example of how a data provider can generate data
19 19 */
20 class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider {
20 class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider
21 {
21 22 Q_OBJECT
22 23 public:
23 24 explicit AmdaProvider();
24 25 std::shared_ptr<IDataProvider> clone() const override;
25 26
26 virtual IDataSeries *getData(const DataProviderParameters &parameters)override;
27
27 virtual TimeSeries::ITimeSerie* getData(const DataProviderParameters& parameters) override;
28 28 };
29 29
30 30 #endif // SCIQLOP_AMDAPROVIDER_H
Show file before | Show file after | Hide comments
@@ -7,18 +7,18
7 7 #include <Data/DataProviderParameters.h>
8 8 #include <Network/NetworkController.h>
9 9 #include <SqpApplication.h>
10 #include <Variable/Variable.h>
11 10
11 #include <Network/Downloader.h>
12 #include <QJsonDocument>
12 13 #include <QNetworkAccessManager>
13 14 #include <QNetworkReply>
14 15 #include <QTemporaryFile>
15 16 #include <QThread>
16 #include <QJsonDocument>
17 #include <Network/Downloader.h>
18 17
19 18 Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
20 19
21 namespace {
20 namespace
21 {
22 22
23 23 /// URL format for a request on AMDA server. The parameters are as follows:
24 24 /// - %1: server URL
@@ -54,10 +54,7 QString dateFormat(double sqpRange) noexcept
54 54
55 55 } // namespace
56 56
57 AmdaProvider::AmdaProvider()
58 {
59
60 }
57 AmdaProvider::AmdaProvider() {}
61 58
62 59 std::shared_ptr<IDataProvider> AmdaProvider::clone() const
63 60 {
@@ -65,7 +62,7 std::shared_ptr<IDataProvider> AmdaProvider::clone() const
65 62 return std::make_shared<AmdaProvider>();
66 63 }
67 64
68 IDataSeries* AmdaProvider::getData(const DataProviderParameters &parameters)
65 TimeSeries::ITimeSerie* AmdaProvider::getData(const DataProviderParameters& parameters)
69 66 {
70 67 auto range = parameters.m_Range;
71 68 auto metaData = parameters.m_Data;
@@ -74,15 +71,15 IDataSeries* AmdaProvider::getData(const DataProviderParameters &parameters)
74 71 = DataSeriesTypeUtils::fromString(metaData.value(AMDA_DATA_TYPE_KEY).toString());
75 72 auto startDate = dateFormat(range.m_TStart);
76 73 auto endDate = dateFormat(range.m_TEnd);
77 QVariantHash urlProperties{{AMDA_SERVER_KEY, metaData.value(AMDA_SERVER_KEY)}};
78 auto token_url = QString{AMDA_TOKEN_URL_FORMAT}.arg(AmdaServer::instance().url(urlProperties));
74 QVariantHash urlProperties { { AMDA_SERVER_KEY, metaData.value(AMDA_SERVER_KEY) } };
75 auto token_url
76 = QString { AMDA_TOKEN_URL_FORMAT }.arg(AmdaServer::instance().url(urlProperties));
79 77 auto response = Downloader::get(token_url);
80 auto url = QString{AMDA_URL_FORMAT_WITH_TOKEN}.arg(AmdaServer::instance().url(urlProperties),
81 startDate, endDate, productId, QString(response.data()));
78 auto url = QString { AMDA_URL_FORMAT_WITH_TOKEN }.arg(AmdaServer::instance().url(urlProperties),
79 startDate, endDate, productId, QString(response.data()));
82 80 response = Downloader::get(url);
83 81 auto test = QJsonDocument::fromJson(response.data());
84 82 url = test["dataFileURLs"].toString();
85 83 response = Downloader::get(url);
86 return AmdaResultParser::readTxt(QTextStream{response.data()},productValueType);
84 return nullptr; // AmdaResultParser::readTxt(QTextStream { response.data() }, productValueType);
87 85 }
88
Show file before | Show file after | Hide comments
@@ -4,7 +4,6
4 4
5 5 #include <QFile>
6 6
7 #include <Data/IDataSeries.h>
8 7 #include <cmath>
9 8
10 9 Q_LOGGING_CATEGORY(LOG_AmdaResultParser, "AmdaResultParser")
Show file before | Show file after | Hide comments
@@ -67,9 +67,10 extern const QString VALIDATION_FREQUENCY_BOUNDS_PROPERTY;
67 67 // /////// //
68 68
69 69 class Variable;
70 struct VariableState {
71 std::shared_ptr<Variable> m_Variable{nullptr};
72 DateTimeRange m_Range{INVALID_RANGE};
70 struct VariableState
71 {
72 std::shared_ptr<Variable> m_Variable { nullptr };
73 DateTimeRange m_Range { INVALID_RANGE };
73 74 };
74 75
75 76 using VariableId = int;
@@ -80,9 +81,10 using VariablesPool = std::map<VariableId, VariableState>;
80 81 * with each other, and the current range of the group (i.e. range of the last synchronized variable
81 82 * that has been moved)
82 83 */
83 struct SyncGroup {
84 std::set<VariableId> m_Variables{};
85 DateTimeRange m_Range{INVALID_RANGE};
84 struct SyncGroup
85 {
86 std::set<VariableId> m_Variables {};
87 DateTimeRange m_Range { INVALID_RANGE };
86 88 };
87 89
88 90 using SyncGroupId = QUuid;
@@ -92,12 +94,13 using SyncGroupsPool = std::map<SyncGroupId, SyncGroup>;
92 94 * Defines a current state during a fuzzing state. It contains all the variables manipulated during
93 95 * the test, as well as the synchronization status of these variables.
94 96 */
95 struct FuzzingState {
96 const SyncGroup &syncGroup(SyncGroupId id) const;
97 SyncGroup &syncGroup(SyncGroupId id);
97 struct FuzzingState
98 {
99 const SyncGroup& syncGroup(SyncGroupId id) const;
100 SyncGroup& syncGroup(SyncGroupId id);
98 101
99 const VariableState &variableState(VariableId id) const;
100 VariableState &variableState(VariableId id);
102 const VariableState& variableState(VariableId id) const;
103 VariableState& variableState(VariableId id);
101 104
102 105 /// @return the identifier of the synchronization group in which the variable passed in
103 106 /// parameter is located. If the variable is not in any group, returns an invalid identifier
@@ -119,7 +122,7 struct FuzzingState {
119 122 /// Updates the range of a variable and all variables to which it is synchronized
120 123 /// @param the variable for which to affect the range
121 124 /// @param the range to affect
122 void updateRanges(VariableId variableId, const DateTimeRange &newRange);
125 void updateRanges(VariableId variableId, const DateTimeRange& newRange);
123 126
124 127 VariablesPool m_VariablesPool;
125 128 SyncGroupsPool m_SyncGroupsPool;
Show file before | Show file after | Hide comments
@@ -13,17 +13,18
13 13 /**
14 14 * @brief The CosinusProvider class is an example of how a data provider can generate data
15 15 */
16 class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider {
16 class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider
17 {
17 18 public:
18 19 std::shared_ptr<IDataProvider> clone() const override;
19 20
20 virtual IDataSeries* getData(const DataProviderParameters &parameters) override;
21 virtual TimeSeries::ITimeSerie* getData(const DataProviderParameters& parameters) override;
21 22
22 23 private:
23 std::shared_ptr<IDataSeries>
24 retrieveData(QUuid acqIdentifier, const DateTimeRange &dataRangeRequested, const QVariantHash &data);
24 std::shared_ptr<IDataSeries> retrieveData(
25 QUuid acqIdentifier, const DateTimeRange& dataRangeRequested, const QVariantHash& data);
25 26
26 IDataSeries* _generate(const DateTimeRange &range, const QVariantHash &metaData);
27 TimeSeries::ITimeSerie* _generate(const DateTimeRange& range, const QVariantHash& metaData);
27 28
28 29 QHash<QUuid, bool> m_VariableToEnableProvider;
29 30 };
Show file before | Show file after | Hide comments
@@ -2,9 +2,9
2 2 #include "MockDefs.h"
3 3
4 4 #include <Data/DataProviderParameters.h>
5 #include <Data/ScalarSeries.h>
6 #include <Data/SpectrogramSeries.h>
7 #include <Data/VectorSeries.h>
5 #include <Data/ScalarTimeSerie.h>
6 #include <Data/SpectrogramTimeSerie.h>
7 #include <Data/VectorTimeSerie.h>
8 8
9 9 #include <cmath>
10 10 #include <set>
@@ -14,145 +14,18
14 14 #include <QtConcurrent/QtConcurrent>
15 15
16 16
17 namespace {
17 namespace
18 {
18 19
19 20 /// Number of bands generated for a spectrogram
20 21 const auto SPECTROGRAM_NUMBER_BANDS = 30;
21 22
22 23 /// Bands for which to generate NaN values for a spectrogram
23 const auto SPECTROGRAM_NAN_BANDS = std::set<int>{1, 3, 10, 20};
24 const auto SPECTROGRAM_NAN_BANDS = std::set<int> { 1, 3, 10, 20 };
24 25
25 26 /// Bands for which to generate zeros for a spectrogram
26 const auto SPECTROGRAM_ZERO_BANDS = std::set<int>{2, 15, 19, 29};
27
28 /// Abstract cosinus type
29 struct ICosinusType {
30 virtual ~ICosinusType() = default;
31 /// @return the number of components generated for the type
32 virtual std::size_t componentCount() const = 0;
33 /// @return the data series created for the type
34 virtual IDataSeries* createDataSeries(std::vector<double> xAxisData,
35 std::vector<double> valuesData) const = 0;
36 /// Generates values (one value per component)
37 /// @param x the x-axis data used to generate values
38 /// @param values the vector in which to insert the generated values
39 /// @param dataIndex the index of insertion of the generated values
40 ///
41 virtual void generateValues(double x, std::vector<double> &values, int dataIndex) const = 0;
42 };
43
44 struct ScalarCosinus : public ICosinusType {
45 std::size_t componentCount() const override { return 1; }
46
47 IDataSeries* createDataSeries(std::vector<double> xAxisData,
48 std::vector<double> valuesData) const override
49 {
50 return new ScalarSeries(std::move(xAxisData), std::move(valuesData),
51 Unit{QStringLiteral("t"), true}, Unit{});
52 }
53
54 void generateValues(double x, std::vector<double> &values, int dataIndex) const override
55 {
56 values[dataIndex] = std::cos(x);
57 }
58 };
59
60 struct SpectrogramCosinus : public ICosinusType {
61 /// Ctor with y-axis
62 explicit SpectrogramCosinus(std::vector<double> yAxisData, Unit yAxisUnit, Unit valuesUnit)
63 : m_YAxisData{std::move(yAxisData)},
64 m_YAxisUnit{std::move(yAxisUnit)},
65 m_ValuesUnit{std::move(valuesUnit)}
66 {
67 }
68
69 std::size_t componentCount() const override { return m_YAxisData.size(); }
70
71 IDataSeries* createDataSeries(std::vector<double> xAxisData,
72 std::vector<double> valuesData) const override
73 {
74 return new SpectrogramSeries(
75 std::move(xAxisData), m_YAxisData, std::move(valuesData),
76 Unit{QStringLiteral("t"), true}, m_YAxisUnit, m_ValuesUnit);
77 }
78
79 void generateValues(double x, std::vector<double> &values, int dataIndex) const override
80 {
81 auto componentCount = this->componentCount();
82 for (int i = 0; i < componentCount; ++i) {
83 auto y = m_YAxisData[i];
84
85 double value;
86
87 // if (SPECTROGRAM_ZERO_BANDS.find(y) != SPECTROGRAM_ZERO_BANDS.end()) {
88 // value = 0.;
89 // }
90 // else if (SPECTROGRAM_NAN_BANDS.find(y) != SPECTROGRAM_NAN_BANDS.end()) {
91 // value = std::numeric_limits<double>::quiet_NaN();
92 // }
93 // else
94 {
95 // Generates value for non NaN/zero bands
96 //auto r = 3 * std::sqrt(x * x + y * y) + 1e-2;
97 //value = 2 * x * (std::cos(r + 2) / r - std::sin(r + 2) / r);
98 value = x + 10*y;
99 }
100
101 values[componentCount * dataIndex + i] = value;
102 }
103 }
104
105 std::vector<double> m_YAxisData;
106 Unit m_YAxisUnit;
107 Unit m_ValuesUnit;
108 };
109
110 struct VectorCosinus : public ICosinusType {
111 std::size_t componentCount() const override { return 3; }
27 const auto SPECTROGRAM_ZERO_BANDS = std::set<int> { 2, 15, 19, 29 };
112 28
113 IDataSeries* createDataSeries(std::vector<double> xAxisData,
114 std::vector<double> valuesData) const override
115 {
116 return new VectorSeries(std::move(xAxisData), std::move(valuesData),
117 Unit{QStringLiteral("t"), true}, Unit{});
118 }
119
120 void generateValues(double x, std::vector<double> &values, int dataIndex) const override
121 {
122 // Generates value for each component: cos(x), cos(x)/2, cos(x)/3
123 auto xValue = std::cos(x);
124 auto componentCount = this->componentCount();
125 for (auto i = 0; i < componentCount; ++i) {
126 values[componentCount * dataIndex + i] = xValue / (i + 1);
127 }
128 }
129 };
130
131 /// Converts string to cosinus type
132 /// @return the cosinus type if the string could be converted, nullptr otherwise
133 std::unique_ptr<ICosinusType> cosinusType(const QString &type) noexcept
134 {
135 if (type.compare(QStringLiteral("scalar"), Qt::CaseInsensitive) == 0) {
136 return std::make_unique<ScalarCosinus>();
137 }
138 else if (type.compare(QStringLiteral("spectrogram"), Qt::CaseInsensitive) == 0) {
139 // Generates default y-axis data for spectrogram [0., 1., 2., ...]
140 std::vector<double> yAxisData(SPECTROGRAM_NUMBER_BANDS);
141 std::iota(yAxisData.begin(), yAxisData.end(), 1.);
142 for (auto & v:yAxisData)
143 {
144 v = std::pow(2,v);
145 }
146 return std::make_unique<SpectrogramCosinus>(std::move(yAxisData), Unit{"eV"},
147 Unit{"eV/(cm^2-s-sr-eV)"});
148 }
149 else if (type.compare(QStringLiteral("vector"), Qt::CaseInsensitive) == 0) {
150 return std::make_unique<VectorCosinus>();
151 }
152 else {
153 return nullptr;
154 }
155 }
156 29
157 30 } // namespace
158 31
@@ -162,43 +35,53 std::shared_ptr<IDataProvider> CosinusProvider::clone() const
162 35 return std::make_shared<CosinusProvider>();
163 36 }
164 37
165 IDataSeries *CosinusProvider::_generate(const DateTimeRange &range, const QVariantHash &metaData)
38 TimeSeries::ITimeSerie* CosinusProvider::_generate(
39 const DateTimeRange& range, const QVariantHash& metaData)
166 40 {
167 auto dataIndex = 0;
168
169 41 // Retrieves cosinus type
170 42 auto typeVariant = metaData.value(COSINUS_TYPE_KEY, COSINUS_TYPE_DEFAULT_VALUE);
171 auto type = cosinusType(typeVariant.toString());
172 43 auto freqVariant = metaData.value(COSINUS_FREQUENCY_KEY, COSINUS_FREQUENCY_DEFAULT_VALUE);
44 const auto fs = 200.;
173 45 double freq = freqVariant.toDouble();
174 46 double start = std::ceil(range.m_TStart * freq);
175 47 double end = std::floor(range.m_TEnd * freq);
176 if (end < start) {
48 if (end < start)
49 {
177 50 std::swap(start, end);
178 51 }
179 52 std::size_t dataCount = static_cast<std::size_t>(end - start + 1);
180 std::size_t componentCount = type->componentCount();
181
182 auto xAxisData = std::vector<double>{};
183 xAxisData.resize(dataCount);
184
185 auto valuesData = std::vector<double>{};
186 valuesData.resize(dataCount * componentCount);
187
188 int progress = 0;
189 auto progressEnd = dataCount;
190 for (auto time = start; time <= end; ++time, ++dataIndex)
53 if (typeVariant.toString() == QStringLiteral("scalar"))
191 54 {
192 const auto x = time / freq;
193 xAxisData[dataIndex] = x;
194 // Generates values (depending on the type)
195 type->generateValues(x, valuesData, dataIndex);
55 auto ts = new ScalarTimeSerie(dataCount);
56 std::generate(
57 std::begin(*ts), std::end(*ts), [range, freq, fs, dt = 1. / freq, i = 0.]() mutable {
58 auto t = range.m_TStart + i * dt;
59 i++;
60 return std::pair<double, double> { t, std::cos(2 * 3.14 * freq / fs * t) };
61 });
62 return ts;
196 63 }
197 return type->createDataSeries(std::move(xAxisData), std::move(valuesData));
64 if (typeVariant.toString() == QStringLiteral("vector"))
65 {
66 auto ts = new VectorTimeSerie(dataCount);
67 std::generate(
68 std::begin(*ts), std::end(*ts), [range, freq, fs, dt = 1. / freq, i = 0.]() mutable {
69 auto t = range.m_TStart + i * dt;
70 i++;
71 return std::pair<double, VectorTimeSerie::raw_value_type> { t,
72 { std::cos(2 * 3.14 * freq / fs * t), std::sin(2 * 3.14 * freq / fs * t),
73 std::cos(2 * 3.14 * freq / fs * t) * std::sin(2 * 3.14 * freq / fs * t) } };
74 });
75 return ts;
76 }
77 if (typeVariant.toString() == QStringLiteral("spectrogram"))
78 {
79 return nullptr;
80 }
81 return nullptr;
198 82 }
199 83
200 IDataSeries* CosinusProvider::getData(const DataProviderParameters &parameters)
84 TimeSeries::ITimeSerie* CosinusProvider::getData(const DataProviderParameters& parameters)
201 85 {
202 86 return _generate(parameters.m_Range, parameters.m_Data);
203 87 }
204
Show file before | Show file after | Hide comments
@@ -19,45 +19,41
19 19 /*-- Author : Alexis Jeandet
20 20 -- Mail : alexis.jeandet@member.fsf.org
21 21 ----------------------------------------------------------------------------*/
22 #include <string>
23 #include <sstream>
24 22 #include <memory>
23 #include <sstream>
24 #include <string>
25 25
26 #include <pybind11/pybind11.h>
27 #include <pybind11/operators.h>
26 #include <pybind11/chrono.h>
28 27 #include <pybind11/embed.h>
29 28 #include <pybind11/numpy.h>
30 #include <pybind11/chrono.h>
29 #include <pybind11/operators.h>
30 #include <pybind11/pybind11.h>
31 31
32 #include <Common/DateUtils.h>
33 #include <Data/DataSeriesType.h>
34 #include <Data/DateTimeRange.h>
32 35 #include <SqpApplication.h>
33 #include <Variable/VariableController2.h>
34 36 #include <Time/TimeController.h>
35 #include <Data/DateTimeRange.h>
36 #include <Data/DataSeriesType.h>
37 #include <Common/DateUtils.h>
38 #include <Variable/Variable.h>
39 #include <Data/ScalarSeries.h>
40 #include <Data/VectorSeries.h>
37 #include <Variable/VariableController2.h>
41 38
42 #include <MockPlugin.h>
43 39 #include <CosinusProvider.h>
40 #include <MockPlugin.h>
44 41
45 42 #include <QFile>
46 43
47 #include <pywrappers_common.h>
48 44 #include <CoreWrappers.h>
49
45 #include <pywrappers_common.h>
50 46
51 47
52 48 using namespace std::chrono;
53 49 namespace py = pybind11;
54 50
55 51
56
57 PYBIND11_MODULE(pytestmockplugin, m){
52 PYBIND11_MODULE(pytestmockplugin, m)
53 {
58 54
59 55 int argc = 0;
60 char ** argv=nullptr;
56 char** argv = nullptr;
61 57 SqpApplication::setOrganizationName("LPP");
62 58 SqpApplication::setOrganizationDomain("lpp.fr");
63 59 SqpApplication::setApplicationName("SciQLop");
@@ -68,18 +64,23 PYBIND11_MODULE(pytestmockplugin, m){
68 64
69 65 m.doc() = "";
70 66
71 py::class_<VariableController2>(m, "VariableController2").def_static("createVariable",[](const QString &name,
72 std::shared_ptr<IDataProvider> provider, const DateTimeRange& range){
73 return sqpApp->variableController().createVariable(name, {{"cosinusType", "spectrogram"}, {"cosinusFrequency", "0.1"}}, provider, range);
67 py::class_<VariableController2>(m, "VariableController2")
68 .def_static("createVariable",
69 [](const QString& name, std::shared_ptr<IDataProvider> provider,
70 const DateTimeRange& range) {
71 return sqpApp->variableController().createVariable(name,
72 { { "cosinusType", "spectrogram" }, { "cosinusFrequency", "0.1" } }, provider,
73 range);
74 });
75
76 py::class_<TimeController>(m, "TimeController").def_static("setTime", [](DateTimeRange range) {
77 sqpApp->timeController().setDateTimeRange(range);
74 78 });
75 79
76 py::class_<TimeController>(m,"TimeController")
77 .def_static("setTime", [](DateTimeRange range){sqpApp->timeController().setDateTimeRange(range);});
78
79 80 auto mock_provider = std::make_shared<CosinusProvider>();
80 m.def("mock_provider",[mock_provider](){return mock_provider;}, py::return_value_policy::copy);
81
82 py::class_<CosinusProvider, std::shared_ptr<CosinusProvider>, IDataProvider>(m, "CosinusProvider");
81 m.def("mock_provider", [mock_provider]() { return mock_provider; },
82 py::return_value_policy::copy);
83 83
84 py::class_<CosinusProvider, std::shared_ptr<CosinusProvider>, IDataProvider>(
85 m, "CosinusProvider");
84 86 }
85
General Comments 0
You need to be logged in to leave comments. Login now