|
|
#pragma once
|
|
|
#include <Data/DataProviderParameters.h>
|
|
|
#include <Data/DataSeriesType.h>
|
|
|
#include <Data/IDataProvider.h>
|
|
|
#include <DataSource/DataSourceController.h>
|
|
|
#include <DataSource/DataSourceItem.h>
|
|
|
#include <DataSource/DataSourceItemAction.h>
|
|
|
#include <QPair>
|
|
|
#include <SqpApplication.h>
|
|
|
// must be included last because of Python/Qt definition of slots
|
|
|
#include "numpy_wrappers.h"
|
|
|
|
|
|
struct Product
|
|
|
{
|
|
|
QString path;
|
|
|
std::vector<std::string> components;
|
|
|
QMap<QString, QString> metadata;
|
|
|
Product() = default;
|
|
|
explicit Product(const QString& path, const std::vector<std::string>& components,
|
|
|
const QMap<QString, QString>& metadata)
|
|
|
: path { path }, components { components }, metadata { metadata }
|
|
|
{
|
|
|
}
|
|
|
~Product() = default;
|
|
|
};
|
|
|
|
|
|
template <typename T>
|
|
|
ScalarTimeSerie* make_scalar(T& t, T& y)
|
|
|
{
|
|
|
return new ScalarTimeSerie { std::move(t.data), std::move(y.data) };
|
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
|
VectorTimeSerie* make_vector(T& t, T& y)
|
|
|
{
|
|
|
return new VectorTimeSerie { std::move(t.data), y.to_std_vect_vect() };
|
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
|
MultiComponentTimeSerie* make_multi_comp(T& t, T& y)
|
|
|
{
|
|
|
auto y_size = y.flat_size();
|
|
|
auto t_size = t.flat_size();
|
|
|
if (t_size && (y_size % t_size) == 0)
|
|
|
{
|
|
|
return new MultiComponentTimeSerie { std::move(t.data), std::move(y.data),
|
|
|
{ t_size, y_size / t_size } };
|
|
|
}
|
|
|
return nullptr;
|
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
|
SpectrogramTimeSerie* make_spectro(T& t, T& y)
|
|
|
{
|
|
|
auto y_size = y.flat_size();
|
|
|
auto t_size = t.flat_size();
|
|
|
if (t_size && (y_size % t_size) == 0)
|
|
|
{
|
|
|
return new SpectrogramTimeSerie { std::move(t.data), std::move(y.data),
|
|
|
{ t_size, y_size / t_size } };
|
|
|
}
|
|
|
return nullptr;
|
|
|
}
|
|
|
|
|
|
|
|
|
class PyDataProvider : public IDataProvider
|
|
|
{
|
|
|
public:
|
|
|
PyDataProvider()
|
|
|
{
|
|
|
auto& dataSourceController = sqpApp->dataSourceController();
|
|
|
dataSourceController.registerProvider(this);
|
|
|
}
|
|
|
|
|
|
virtual ~PyDataProvider() {}
|
|
|
|
|
|
virtual QPair<QPair<NpArray, NpArray>, DataSeriesType> get_data(
|
|
|
const QMap<QString, QString>& key, double start_time, double stop_time)
|
|
|
{
|
|
|
(void)key, (void)start_time, (void)stop_time;
|
|
|
return {};
|
|
|
}
|
|
|
|
|
|
virtual TimeSeries::ITimeSerie* getData(const DataProviderParameters& parameters) override
|
|
|
{
|
|
|
TimeSeries::ITimeSerie* ts = nullptr;
|
|
|
if (parameters.m_Data.contains("name"))
|
|
|
{
|
|
|
QMap<QString, QString> metadata;
|
|
|
std::for_each(parameters.m_Data.constKeyValueBegin(),
|
|
|
parameters.m_Data.constKeyValueEnd(),
|
|
|
[&metadata](const auto& item) { metadata[item.first] = item.second.toString(); });
|
|
|
auto [data, type]
|
|
|
= get_data(metadata, parameters.m_Range.m_TStart, parameters.m_Range.m_TEnd);
|
|
|
|
|
|
auto& [t, y] = data;
|
|
|
switch (type)
|
|
|
{
|
|
|
case DataSeriesType::SCALAR:
|
|
|
ts = make_scalar(t, y);
|
|
|
break;
|
|
|
case DataSeriesType::VECTOR:
|
|
|
ts = make_vector(t, y);
|
|
|
break;
|
|
|
case DataSeriesType::MULTICOMPONENT:
|
|
|
ts = make_multi_comp(t, y);
|
|
|
break;
|
|
|
case DataSeriesType::SPECTROGRAM:
|
|
|
ts = make_spectro(t, y);
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
return ts;
|
|
|
}
|
|
|
|
|
|
|
|
|
inline void register_products(const QVector<Product*>& products)
|
|
|
{
|
|
|
auto& dataSourceController = sqpApp->dataSourceController();
|
|
|
auto id = this->id();
|
|
|
auto data_source_name = this->name();
|
|
|
std::for_each(std::cbegin(products), std::cend(products),
|
|
|
[&id, &dataSourceController](const Product* product) {
|
|
|
dataSourceController.setDataSourceItem(id, product->path, product->metadata);
|
|
|
});
|
|
|
}
|
|
|
};
|
|
|
|
