|
|
@@
-1,302
+1,297
|
|
|
1
|
#include "CoreWrappers.h"
|
|
1
|
#include "CoreWrappers.h"
|
|
|
2
|
|
|
2
|
|
|
|
3
|
#include "pywrappers_common.h"
|
|
3
|
#include "pywrappers_common.h"
|
|
|
4
|
|
|
4
|
|
|
|
5
|
#include <Common/debug.h>
|
|
5
|
#include <Common/debug.h>
|
|
|
6
|
#include <Data/DataSeriesType.h>
|
|
6
|
#include <Data/DataSeriesType.h>
|
|
|
7
|
#include <Data/IDataProvider.h>
|
|
7
|
#include <Data/IDataProvider.h>
|
|
|
8
|
#include <Network/Downloader.h>
|
|
8
|
#include <Network/Downloader.h>
|
|
|
9
|
#include <Time/TimeController.h>
|
|
9
|
#include <Time/TimeController.h>
|
|
|
10
|
#include <Variable/Variable2.h>
|
|
10
|
#include <Variable/Variable2.h>
|
|
|
11
|
#include <Variable/VariableController2.h>
|
|
11
|
#include <Variable/VariableController2.h>
|
|
|
12
|
#include <pybind11/chrono.h>
|
|
12
|
#include <pybind11/chrono.h>
|
|
|
13
|
#include <pybind11/embed.h>
|
|
13
|
#include <pybind11/embed.h>
|
|
|
14
|
#include <pybind11/functional.h>
|
|
14
|
#include <pybind11/functional.h>
|
|
|
15
|
#include <pybind11/numpy.h>
|
|
15
|
#include <pybind11/numpy.h>
|
|
|
16
|
#include <pybind11/operators.h>
|
|
16
|
#include <pybind11/operators.h>
|
|
|
17
|
#include <pybind11/pybind11.h>
|
|
17
|
#include <pybind11/pybind11.h>
|
|
|
18
|
#include <pybind11/stl.h>
|
|
18
|
#include <pybind11/stl.h>
|
|
|
19
|
#include <pybind11/stl_bind.h>
|
|
19
|
#include <pybind11/stl_bind.h>
|
|
|
20
|
#include <sstream>
|
|
20
|
#include <sstream>
|
|
|
21
|
#include <string>
|
|
21
|
#include <string>
|
|
|
22
|
|
|
22
|
|
|
|
23
|
namespace py = pybind11;
|
|
23
|
namespace py = pybind11;
|
|
|
24
|
using namespace std::chrono;
|
|
24
|
using namespace std::chrono;
|
|
|
25
|
|
|
25
|
|
|
|
26
|
template<typename T, typename U, bool row_major = true>
|
|
26
|
template<typename T, typename U, bool row_major = true>
|
|
|
27
|
void copy_vector(py::array_t<double>& t, py::array_t<double>& values, T& dest_t,
|
|
27
|
void copy_vector(py::array_t<double>& t, py::array_t<double>& values, T& dest_t,
|
|
|
28
|
U& dest_values)
|
|
28
|
U& dest_values)
|
|
|
29
|
{
|
|
29
|
{
|
|
|
30
|
auto t_view = t.unchecked<1>();
|
|
30
|
auto t_view = t.unchecked<1>();
|
|
|
31
|
auto values_view = values.unchecked<2>();
|
|
31
|
auto values_view = values.unchecked<2>();
|
|
|
32
|
for(std::size_t i = 0; i < t.size(); i++)
|
|
32
|
for(std::size_t i = 0; i < t.size(); i++)
|
|
|
33
|
{
|
|
33
|
{
|
|
|
34
|
dest_t[i] = t_view[i];
|
|
34
|
dest_t[i] = t_view[i];
|
|
|
35
|
dest_values[i] = {values_view(i, 0), values_view(i, 1), values_view(i, 2)};
|
|
35
|
dest_values[i] = {values_view(i, 0), values_view(i, 1), values_view(i, 2)};
|
|
|
36
|
}
|
|
36
|
}
|
|
|
37
|
}
|
|
37
|
}
|
|
|
38
|
|
|
38
|
|
|
|
39
|
template<typename T, typename U>
|
|
39
|
template<typename T, typename U>
|
|
|
40
|
void copy_scalar(py::array_t<double>& t, py::array_t<double>& values, T& dest_t,
|
|
40
|
void copy_scalar(py::array_t<double>& t, py::array_t<double>& values, T& dest_t,
|
|
|
41
|
U& dest_values)
|
|
41
|
U& dest_values)
|
|
|
42
|
{
|
|
42
|
{
|
|
|
43
|
auto t_view = t.unchecked<1>();
|
|
43
|
auto t_view = t.unchecked<1>();
|
|
|
44
|
if(values.ndim() == 1)
|
|
44
|
if(values.ndim() == 1)
|
|
|
45
|
{
|
|
45
|
{
|
|
|
46
|
auto values_view = values.unchecked<1>();
|
|
46
|
auto values_view = values.unchecked<1>();
|
|
|
47
|
for(std::size_t i = 0; i < t.size(); i++)
|
|
47
|
for(std::size_t i = 0; i < t.size(); i++)
|
|
|
48
|
{
|
|
48
|
{
|
|
|
49
|
dest_t[i] = t_view[i];
|
|
49
|
dest_t[i] = t_view[i];
|
|
|
50
|
dest_values[i] = values_view[i];
|
|
50
|
dest_values[i] = values_view[i];
|
|
|
51
|
}
|
|
51
|
}
|
|
|
52
|
}
|
|
52
|
}
|
|
|
53
|
else if(values.ndim() == 2 && values.shape(1) == 1)
|
|
53
|
else if(values.ndim() == 2 && values.shape(1) == 1)
|
|
|
54
|
{
|
|
54
|
{
|
|
|
55
|
auto values_view = values.unchecked<2>();
|
|
55
|
auto values_view = values.unchecked<2>();
|
|
|
56
|
for(std::size_t i = 0; i < t.size(); i++)
|
|
56
|
for(std::size_t i = 0; i < t.size(); i++)
|
|
|
57
|
{
|
|
57
|
{
|
|
|
58
|
dest_t[i] = t_view[i];
|
|
58
|
dest_t[i] = t_view[i];
|
|
|
59
|
dest_values[i] = values_view(i, 0);
|
|
59
|
dest_values[i] = values_view(i, 0);
|
|
|
60
|
}
|
|
60
|
}
|
|
|
61
|
}
|
|
61
|
}
|
|
|
62
|
}
|
|
62
|
}
|
|
|
63
|
template<typename T, typename U>
|
|
63
|
template<typename T, typename U>
|
|
|
64
|
void copy_multicomp(py::array_t<double>& t, py::array_t<double>& values,
|
|
64
|
void copy_multicomp(py::array_t<double>& t, py::array_t<double>& values,
|
|
|
65
|
T& dest_t, U& dest_values)
|
|
65
|
T& dest_t, U& dest_values)
|
|
|
66
|
{
|
|
66
|
{
|
|
|
67
|
auto t_view = t.unchecked<1>();
|
|
67
|
auto t_view = t.unchecked<1>();
|
|
|
68
|
auto values_view = values.unchecked<2>();
|
|
68
|
auto values_view = values.unchecked<2>();
|
|
|
69
|
const auto width = values.shape(1);
|
|
69
|
const auto width = values.shape(1);
|
|
|
70
|
for(std::size_t i = 0; i < t.size(); i++)
|
|
70
|
for(std::size_t i = 0; i < t.size(); i++)
|
|
|
71
|
{
|
|
71
|
{
|
|
|
72
|
dest_t[i] = t_view[i];
|
|
72
|
dest_t[i] = t_view[i];
|
|
|
73
|
for(int j = 0; j < width; j++)
|
|
73
|
for(int j = 0; j < width; j++)
|
|
|
74
|
{
|
|
74
|
{
|
|
|
75
|
dest_values[i * width + j] = values_view(i, j);
|
|
75
|
dest_values[i * width + j] = values_view(i, j);
|
|
|
76
|
}
|
|
76
|
}
|
|
|
77
|
}
|
|
77
|
}
|
|
|
78
|
}
|
|
78
|
}
|
|
|
79
|
|
|
79
|
|
|
|
80
|
template<typename T, typename U>
|
|
80
|
template<typename T, typename U>
|
|
|
81
|
void copy_spectro(py::array_t<double>& t, py::array_t<double>& y,
|
|
81
|
void copy_spectro(py::array_t<double>& t, py::array_t<double>& y,
|
|
|
82
|
py::array_t<double>& values, T& dest_t, T& dest_y,
|
|
82
|
py::array_t<double>& values, T& dest_t, T& dest_y,
|
|
|
83
|
U& dest_values)
|
|
83
|
U& dest_values)
|
|
|
84
|
{
|
|
84
|
{
|
|
|
85
|
auto t_view = t.unchecked<1>();
|
|
85
|
auto t_view = t.unchecked<1>();
|
|
|
86
|
auto y_view = y.unchecked<1>();
|
|
86
|
auto y_view = y.unchecked<1>();
|
|
|
87
|
auto values_view = values.unchecked<2>();
|
|
87
|
auto values_view = values.unchecked<2>();
|
|
|
88
|
const auto width = values.shape(1);
|
|
88
|
const auto width = values.shape(1);
|
|
|
89
|
for(std::size_t i = 0; i < y.size(); i++)
|
|
89
|
for(std::size_t i = 0; i < y.size(); i++)
|
|
|
90
|
{
|
|
90
|
{
|
|
|
91
|
dest_y[i] = y_view[i];
|
|
91
|
dest_y[i] = y_view[i];
|
|
|
92
|
}
|
|
92
|
}
|
|
|
93
|
for(std::size_t i = 0; i < t.size(); i++)
|
|
93
|
for(std::size_t i = 0; i < t.size(); i++)
|
|
|
94
|
{
|
|
94
|
{
|
|
|
95
|
dest_t[i] = t_view[i];
|
|
95
|
dest_t[i] = t_view[i];
|
|
|
96
|
for(int j = 0; j < width; j++)
|
|
96
|
for(int j = 0; j < width; j++)
|
|
|
97
|
{
|
|
97
|
{
|
|
|
98
|
dest_values[i * width + j] = values_view(i, j);
|
|
98
|
dest_values[i * width + j] = values_view(i, j);
|
|
|
99
|
}
|
|
99
|
}
|
|
|
100
|
}
|
|
100
|
}
|
|
|
101
|
}
|
|
101
|
}
|
|
|
102
|
|
|
102
|
|
|
|
103
|
PYBIND11_MODULE(pysciqlopcore, m)
|
|
103
|
PYBIND11_MODULE(pysciqlopcore, m)
|
|
|
104
|
{
|
|
104
|
{
|
|
|
105
|
pybind11::bind_vector<std::vector<double>>(m, "VectorDouble");
|
|
105
|
pybind11::bind_vector<std::vector<double>>(m, "VectorDouble");
|
|
|
106
|
|
|
106
|
|
|
|
107
|
py::enum_<DataSeriesType>(m, "DataSeriesType")
|
|
107
|
py::enum_<DataSeriesType>(m, "DataSeriesType")
|
|
|
108
|
.value("SCALAR", DataSeriesType::SCALAR)
|
|
108
|
.value("SCALAR", DataSeriesType::SCALAR)
|
|
|
109
|
.value("SPECTROGRAM", DataSeriesType::SPECTROGRAM)
|
|
109
|
.value("SPECTROGRAM", DataSeriesType::SPECTROGRAM)
|
|
|
110
|
.value("VECTOR", DataSeriesType::VECTOR)
|
|
110
|
.value("VECTOR", DataSeriesType::VECTOR)
|
|
|
111
|
.value("MULTICOMPONENT", DataSeriesType::MULTICOMPONENT)
|
|
111
|
.value("MULTICOMPONENT", DataSeriesType::MULTICOMPONENT)
|
|
|
112
|
.value("NONE", DataSeriesType::NONE)
|
|
112
|
.value("NONE", DataSeriesType::NONE)
|
|
|
113
|
.export_values();
|
|
113
|
.export_values();
|
|
|
114
|
|
|
114
|
|
|
|
115
|
py::class_<Response>(m, "Response")
|
|
115
|
py::class_<Response>(m, "Response")
|
|
|
116
|
.def("status_code", &Response::status_code);
|
|
116
|
.def("status_code", &Response::status_code);
|
|
|
117
|
|
|
117
|
|
|
|
118
|
py::class_<Downloader>(m, "Downloader")
|
|
118
|
py::class_<Downloader>(m, "Downloader")
|
|
|
119
|
.def_static("get", Downloader::get)
|
|
119
|
.def_static("get", Downloader::get)
|
|
|
120
|
.def_static("getAsync", Downloader::getAsync)
|
|
120
|
.def_static("getAsync", Downloader::getAsync)
|
|
|
121
|
.def_static("downloadFinished", Downloader::downloadFinished);
|
|
121
|
.def_static("downloadFinished", Downloader::downloadFinished);
|
|
|
122
|
|
|
122
|
|
|
|
123
|
py::class_<IDataProvider, std::shared_ptr<IDataProvider>>(m, "IDataProvider");
|
|
123
|
py::class_<IDataProvider, std::shared_ptr<IDataProvider>>(m, "IDataProvider");
|
|
|
124
|
|
|
124
|
|
|
|
125
|
py::class_<TimeSeries::ITimeSerie, std::shared_ptr<TimeSeries::ITimeSerie>>(
|
|
125
|
py::class_<TimeSeries::ITimeSerie, std::shared_ptr<TimeSeries::ITimeSerie>>(
|
|
|
126
|
m, "ITimeSerie")
|
|
126
|
m, "ITimeSerie")
|
|
|
127
|
.def_property_readonly(
|
|
127
|
.def_property_readonly(
|
|
|
128
|
"size", [](const TimeSeries::ITimeSerie& ts) { return ts.size(); })
|
|
128
|
"size", [](const TimeSeries::ITimeSerie& ts) { return ts.size(); })
|
|
|
129
|
.def("__len__",
|
|
129
|
.def("__len__",
|
|
|
130
|
[](const TimeSeries::ITimeSerie& ts) { return ts.size(); })
|
|
130
|
[](const TimeSeries::ITimeSerie& ts) { return ts.size(); })
|
|
|
131
|
.def_property_readonly(
|
|
131
|
.def_property_readonly(
|
|
|
132
|
"shape", [](const TimeSeries::ITimeSerie& ts) { return ts.shape(); })
|
|
132
|
"shape", [](const TimeSeries::ITimeSerie& ts) { return ts.shape(); })
|
|
|
133
|
.def_property_readonly(
|
|
133
|
.def_property_readonly(
|
|
|
134
|
"t",
|
|
134
|
"t",
|
|
|
135
|
[](TimeSeries::ITimeSerie& ts) -> decltype(ts.axis(0))& {
|
|
135
|
[](TimeSeries::ITimeSerie& ts) -> decltype(ts.axis(0))& {
|
|
|
136
|
return ts.axis(0);
|
|
136
|
return ts.axis(0);
|
|
|
137
|
},
|
|
137
|
},
|
|
|
138
|
py::return_value_policy::reference)
|
|
138
|
py::return_value_policy::reference)
|
|
|
139
|
.def(
|
|
139
|
.def(
|
|
|
140
|
"axis",
|
|
140
|
"axis",
|
|
|
141
|
[](TimeSeries::ITimeSerie& ts, unsigned int index)
|
|
141
|
[](TimeSeries::ITimeSerie& ts, unsigned int index)
|
|
|
142
|
-> decltype(ts.axis(0))& { return ts.axis(index); },
|
|
142
|
-> decltype(ts.axis(0))& { return ts.axis(index); },
|
|
|
143
|
py::return_value_policy::reference);
|
|
143
|
py::return_value_policy::reference);
|
|
|
144
|
|
|
144
|
|
|
|
145
|
py::class_<ScalarTimeSerie, TimeSeries::ITimeSerie,
|
|
145
|
py::class_<ScalarTimeSerie, TimeSeries::ITimeSerie,
|
|
|
146
|
std::shared_ptr<ScalarTimeSerie>>(m, "ScalarTimeSerie")
|
|
146
|
std::shared_ptr<ScalarTimeSerie>>(m, "ScalarTimeSerie")
|
|
|
147
|
.def(py::init<>())
|
|
147
|
.def(py::init<>())
|
|
|
148
|
.def(py::init<std::size_t>())
|
|
148
|
.def(py::init<std::size_t>())
|
|
|
149
|
.def(py::init([](py::array_t<double> t, py::array_t<double> values) {
|
|
149
|
.def(py::init([](py::array_t<double> t, py::array_t<double> values) {
|
|
|
150
|
assert(t.size() == values.size());
|
|
150
|
assert(t.size() == values.size());
|
|
|
151
|
ScalarTimeSerie::axis_t _t(t.size());
|
|
151
|
ScalarTimeSerie::axis_t _t(t.size());
|
|
|
152
|
ScalarTimeSerie::axis_t _values(t.size());
|
|
152
|
ScalarTimeSerie::axis_t _values(t.size());
|
|
|
153
|
copy_scalar(t, values, _t, _values);
|
|
153
|
copy_scalar(t, values, _t, _values);
|
|
|
154
|
return ScalarTimeSerie(_t, _values);
|
|
154
|
return ScalarTimeSerie(_t, _values);
|
|
|
155
|
}))
|
|
155
|
}))
|
|
|
156
|
.def("__getitem__",
|
|
156
|
.def("__getitem__",
|
|
|
157
|
[](ScalarTimeSerie& ts, std::size_t key) { return ts[key]; })
|
|
157
|
[](ScalarTimeSerie& ts, std::size_t key) { return ts[key]; })
|
|
|
158
|
.def("__setitem__", [](ScalarTimeSerie& ts, std::size_t key,
|
|
158
|
.def("__setitem__", [](ScalarTimeSerie& ts, std::size_t key,
|
|
|
159
|
double value) { *(ts.begin() + key) = value; });
|
|
159
|
double value) { *(ts.begin() + key) = value; });
|
|
|
160
|
|
|
160
|
|
|
|
161
|
py::class_<VectorTimeSerie::raw_value_type>(m, "vector")
|
|
161
|
py::class_<VectorTimeSerie::raw_value_type>(m, "vector")
|
|
|
162
|
.def(py::init<>())
|
|
162
|
.def(py::init<>())
|
|
|
163
|
.def(py::init<double, double, double>())
|
|
163
|
.def(py::init<double, double, double>())
|
|
|
164
|
.def("__repr__", __repr__<VectorTimeSerie::raw_value_type>)
|
|
164
|
.def("__repr__", __repr__<VectorTimeSerie::raw_value_type>)
|
|
|
165
|
.def_readwrite("x", &VectorTimeSerie::raw_value_type::x)
|
|
165
|
.def_readwrite("x", &VectorTimeSerie::raw_value_type::x)
|
|
|
166
|
.def_readwrite("y", &VectorTimeSerie::raw_value_type::y)
|
|
166
|
.def_readwrite("y", &VectorTimeSerie::raw_value_type::y)
|
|
|
167
|
.def_readwrite("z", &VectorTimeSerie::raw_value_type::z);
|
|
167
|
.def_readwrite("z", &VectorTimeSerie::raw_value_type::z);
|
|
|
168
|
|
|
168
|
|
|
|
169
|
py::class_<VectorTimeSerie, TimeSeries::ITimeSerie,
|
|
169
|
py::class_<VectorTimeSerie, TimeSeries::ITimeSerie,
|
|
|
170
|
std::shared_ptr<VectorTimeSerie>>(m, "VectorTimeSerie")
|
|
170
|
std::shared_ptr<VectorTimeSerie>>(m, "VectorTimeSerie")
|
|
|
171
|
.def(py::init<>())
|
|
171
|
.def(py::init<>())
|
|
|
172
|
.def(py::init<std::size_t>())
|
|
172
|
.def(py::init<std::size_t>())
|
|
|
173
|
.def(py::init([](py::array_t<double> t, py::array_t<double> values) {
|
|
173
|
.def(py::init([](py::array_t<double> t, py::array_t<double> values) {
|
|
|
174
|
assert(t.size() * 3 == values.size());
|
|
174
|
assert(t.size() * 3 == values.size());
|
|
|
175
|
VectorTimeSerie::axis_t _t(t.size());
|
|
175
|
VectorTimeSerie::axis_t _t(t.size());
|
|
|
176
|
VectorTimeSerie::container_type<VectorTimeSerie::raw_value_type>
|
|
176
|
VectorTimeSerie::data_t _values(t.size());
|
|
|
177
|
_values(t.size());
|
|
|
|
|
|
178
|
copy_vector(t, values, _t, _values);
|
|
177
|
copy_vector(t, values, _t, _values);
|
|
|
179
|
return VectorTimeSerie(_t, _values);
|
|
178
|
return VectorTimeSerie(_t, _values);
|
|
|
180
|
}))
|
|
179
|
}))
|
|
|
181
|
.def(
|
|
180
|
.def(
|
|
|
182
|
"__getitem__",
|
|
181
|
"__getitem__",
|
|
|
183
|
[](VectorTimeSerie& ts, std::size_t key)
|
|
182
|
[](VectorTimeSerie& ts, std::size_t key)
|
|
|
184
|
-> VectorTimeSerie::raw_value_type& { return ts[key]; },
|
|
183
|
-> VectorTimeSerie::raw_value_type& { return ts[key]; },
|
|
|
185
|
py::return_value_policy::reference)
|
|
184
|
py::return_value_policy::reference)
|
|
|
186
|
.def("__setitem__", [](VectorTimeSerie& ts, std::size_t key,
|
|
185
|
.def("__setitem__", [](VectorTimeSerie& ts, std::size_t key,
|
|
|
187
|
VectorTimeSerie::raw_value_type value) {
|
|
186
|
VectorTimeSerie::raw_value_type value) {
|
|
|
188
|
*(ts.begin() + key) = value;
|
|
187
|
*(ts.begin() + key) = value;
|
|
|
189
|
});
|
|
188
|
});
|
|
|
190
|
|
|
189
|
|
|
|
191
|
py::class_<MultiComponentTimeSerie::iterator_t>(m,
|
|
190
|
py::class_<MultiComponentTimeSerie::iterator_t>(m,
|
|
|
192
|
"MultiComponentTimeSerieItem")
|
|
191
|
"MultiComponentTimeSerieItem")
|
|
|
193
|
.def("__getitem__", [](MultiComponentTimeSerie::iterator_t& self,
|
|
192
|
.def("__getitem__", [](MultiComponentTimeSerie::iterator_t& self,
|
|
|
194
|
std::size_t key) { return (*self)[key]; })
|
|
193
|
std::size_t key) { return (*self)[key]; })
|
|
|
195
|
.def("__setitem__",
|
|
194
|
.def("__setitem__",
|
|
|
196
|
[](MultiComponentTimeSerie::iterator_t& self, std::size_t key,
|
|
195
|
[](MultiComponentTimeSerie::iterator_t& self, std::size_t key,
|
|
|
197
|
double value) { (*self)[key] = value; });
|
|
196
|
double value) { (*self)[key] = value; });
|
|
|
198
|
|
|
197
|
|
|
|
199
|
py::class_<MultiComponentTimeSerie, TimeSeries::ITimeSerie,
|
|
198
|
py::class_<MultiComponentTimeSerie, TimeSeries::ITimeSerie,
|
|
|
200
|
std::shared_ptr<MultiComponentTimeSerie>>(
|
|
199
|
std::shared_ptr<MultiComponentTimeSerie>>(
|
|
|
201
|
m, "MultiComponentTimeSerie")
|
|
200
|
m, "MultiComponentTimeSerie")
|
|
|
202
|
.def(py::init<>())
|
|
201
|
.def(py::init<>())
|
|
|
203
|
.def(py::init<const std::vector<std::size_t>>())
|
|
202
|
.def(py::init<const std::vector<std::size_t>>())
|
|
|
204
|
.def(py::init([](py::array_t<double> t, py::array_t<double> values) {
|
|
203
|
.def(py::init([](py::array_t<double> t, py::array_t<double> values) {
|
|
|
205
|
assert((t.size() < values.size()) |
|
|
204
|
assert((t.size() < values.size()) |
|
|
|
206
|
(t.size() == 0)); // TODO check geometry
|
|
205
|
(t.size() == 0)); // TODO check geometry
|
|
|
207
|
MultiComponentTimeSerie::axis_t _t(t.size());
|
|
206
|
MultiComponentTimeSerie::axis_t _t(t.size());
|
|
|
208
|
MultiComponentTimeSerie::container_type<
|
|
207
|
MultiComponentTimeSerie::data_t _values(values.size());
|
|
|
209
|
MultiComponentTimeSerie::raw_value_type>
|
|
|
|
|
|
210
|
_values(values.size());
|
|
|
|
|
|
211
|
copy_multicomp(t, values, _t, _values);
|
|
208
|
copy_multicomp(t, values, _t, _values);
|
|
|
212
|
std::vector<std::size_t> shape;
|
|
209
|
std::vector<std::size_t> shape;
|
|
|
213
|
shape.push_back(values.shape(0));
|
|
210
|
shape.push_back(values.shape(0));
|
|
|
214
|
shape.push_back(values.shape(1));
|
|
211
|
shape.push_back(values.shape(1));
|
|
|
215
|
return MultiComponentTimeSerie(_t, _values, shape);
|
|
212
|
return MultiComponentTimeSerie(_t, _values, shape);
|
|
|
216
|
}))
|
|
213
|
}))
|
|
|
217
|
.def("__getitem__",
|
|
214
|
.def("__getitem__",
|
|
|
218
|
[](MultiComponentTimeSerie& ts,
|
|
215
|
[](MultiComponentTimeSerie& ts,
|
|
|
219
|
std::size_t key) -> MultiComponentTimeSerie::iterator_t {
|
|
216
|
std::size_t key) -> MultiComponentTimeSerie::iterator_t {
|
|
|
220
|
return ts.begin() + key;
|
|
217
|
return ts.begin() + key;
|
|
|
221
|
});
|
|
218
|
});
|
|
|
222
|
|
|
219
|
|
|
|
223
|
py::class_<SpectrogramTimeSerie::iterator_t>(m, "SpectrogramTimeSerieItem")
|
|
220
|
py::class_<SpectrogramTimeSerie::iterator_t>(m, "SpectrogramTimeSerieItem")
|
|
|
224
|
.def("__getitem__", [](SpectrogramTimeSerie::iterator_t& self,
|
|
221
|
.def("__getitem__", [](SpectrogramTimeSerie::iterator_t& self,
|
|
|
225
|
std::size_t key) { return (*self)[key]; })
|
|
222
|
std::size_t key) { return (*self)[key]; })
|
|
|
226
|
.def("__setitem__",
|
|
223
|
.def("__setitem__",
|
|
|
227
|
[](SpectrogramTimeSerie::iterator_t& self, std::size_t key,
|
|
224
|
[](SpectrogramTimeSerie::iterator_t& self, std::size_t key,
|
|
|
228
|
double value) { (*self)[key] = value; });
|
|
225
|
double value) { (*self)[key] = value; });
|
|
|
229
|
|
|
226
|
|
|
|
230
|
py::class_<SpectrogramTimeSerie, TimeSeries::ITimeSerie,
|
|
227
|
py::class_<SpectrogramTimeSerie, TimeSeries::ITimeSerie,
|
|
|
231
|
std::shared_ptr<SpectrogramTimeSerie>>(m, "SpectrogramTimeSerie")
|
|
228
|
std::shared_ptr<SpectrogramTimeSerie>>(m, "SpectrogramTimeSerie")
|
|
|
232
|
.def(py::init<>())
|
|
229
|
.def(py::init<>())
|
|
|
233
|
.def(py::init<const std::vector<std::size_t>>())
|
|
230
|
.def(py::init<const std::vector<std::size_t>>())
|
|
|
234
|
.def(py::init([](py::array_t<double> t, py::array_t<double> y,
|
|
231
|
.def(py::init([](py::array_t<double> t, py::array_t<double> y,
|
|
|
235
|
py::array_t<double> values, double min_sampling,
|
|
232
|
py::array_t<double> values, double min_sampling,
|
|
|
236
|
double max_sampling, bool y_is_log) {
|
|
233
|
double max_sampling, bool y_is_log) {
|
|
|
237
|
if(t.size() >= values.size() and t.size() != 0)
|
|
234
|
if(t.size() >= values.size() and t.size() != 0)
|
|
|
238
|
SCIQLOP_ERROR(decltype(py::self), "Doesn't look like a Spectrogram");
|
|
235
|
SCIQLOP_ERROR(decltype(py::self), "Doesn't look like a Spectrogram");
|
|
|
239
|
if(y.size() != values.shape(1))
|
|
236
|
if(y.size() != values.shape(1))
|
|
|
240
|
SCIQLOP_ERROR(decltype(py::self),
|
|
237
|
SCIQLOP_ERROR(decltype(py::self),
|
|
|
241
|
"Y axis size and data shape are incompatible");
|
|
238
|
"Y axis size and data shape are incompatible");
|
|
|
242
|
SpectrogramTimeSerie::axis_t _t(t.size());
|
|
239
|
SpectrogramTimeSerie::axis_t _t(t.size());
|
|
|
243
|
SpectrogramTimeSerie::axis_t _y(y.size());
|
|
240
|
SpectrogramTimeSerie::axis_t _y(y.size());
|
|
|
244
|
SpectrogramTimeSerie::container_type<
|
|
241
|
SpectrogramTimeSerie::data_t _values(values.size());
|
|
|
245
|
SpectrogramTimeSerie::raw_value_type>
|
|
|
|
|
|
246
|
_values(values.size());
|
|
|
|
|
|
247
|
copy_spectro(t, y, values, _t, _y, _values);
|
|
242
|
copy_spectro(t, y, values, _t, _y, _values);
|
|
|
248
|
std::vector<std::size_t> shape;
|
|
243
|
std::vector<std::size_t> shape;
|
|
|
249
|
shape.push_back(values.shape(0));
|
|
244
|
shape.push_back(values.shape(0));
|
|
|
250
|
shape.push_back(values.shape(1));
|
|
245
|
shape.push_back(values.shape(1));
|
|
|
251
|
return SpectrogramTimeSerie(std::move(_t), std::move(_y),
|
|
246
|
return SpectrogramTimeSerie(std::move(_t), std::move(_y),
|
|
|
252
|
std::move(_values), shape, min_sampling,
|
|
247
|
std::move(_values), shape, min_sampling,
|
|
|
253
|
max_sampling, y_is_log);
|
|
248
|
max_sampling, y_is_log);
|
|
|
254
|
}))
|
|
249
|
}))
|
|
|
255
|
.def("__getitem__",
|
|
250
|
.def("__getitem__",
|
|
|
256
|
[](SpectrogramTimeSerie& ts,
|
|
251
|
[](SpectrogramTimeSerie& ts,
|
|
|
257
|
std::size_t key) -> SpectrogramTimeSerie::iterator_t {
|
|
252
|
std::size_t key) -> SpectrogramTimeSerie::iterator_t {
|
|
|
258
|
return ts.begin() + key;
|
|
253
|
return ts.begin() + key;
|
|
|
259
|
});
|
|
254
|
});
|
|
|
260
|
|
|
255
|
|
|
|
261
|
py::class_<Variable2, std::shared_ptr<Variable2>>(m, "Variable2")
|
|
256
|
py::class_<Variable2, std::shared_ptr<Variable2>>(m, "Variable2")
|
|
|
262
|
.def(py::init<const QString&>())
|
|
257
|
.def(py::init<const QString&>())
|
|
|
263
|
.def_property("name", &Variable2::name, &Variable2::setName)
|
|
258
|
.def_property("name", &Variable2::name, &Variable2::setName)
|
|
|
264
|
.def_property_readonly("range", &Variable2::range)
|
|
259
|
.def_property_readonly("range", &Variable2::range)
|
|
|
265
|
.def_property_readonly("nbPoints", &Variable2::nbPoints)
|
|
260
|
.def_property_readonly("nbPoints", &Variable2::nbPoints)
|
|
|
266
|
.def_property_readonly(
|
|
261
|
.def_property_readonly(
|
|
|
267
|
"data",
|
|
262
|
"data",
|
|
|
268
|
[](Variable2& var) -> std::shared_ptr<TimeSeries::ITimeSerie> {
|
|
263
|
[](Variable2& var) -> std::shared_ptr<TimeSeries::ITimeSerie> {
|
|
|
269
|
return var.data();
|
|
264
|
return var.data();
|
|
|
270
|
})
|
|
265
|
})
|
|
|
271
|
.def("set_data",
|
|
266
|
.def("set_data",
|
|
|
272
|
[](Variable2& var, std::vector<TimeSeries::ITimeSerie*> ts_list,
|
|
267
|
[](Variable2& var, std::vector<TimeSeries::ITimeSerie*> ts_list,
|
|
|
273
|
const DateTimeRange& range) { var.setData(ts_list, range); })
|
|
268
|
const DateTimeRange& range) { var.setData(ts_list, range); })
|
|
|
274
|
.def("__len__", &Variable2::nbPoints)
|
|
269
|
.def("__len__", &Variable2::nbPoints)
|
|
|
275
|
.def("__repr__", __repr__<Variable2>);
|
|
270
|
.def("__repr__", __repr__<Variable2>);
|
|
|
276
|
|
|
271
|
|
|
|
277
|
py::class_<DateTimeRange>(m, "SqpRange")
|
|
272
|
py::class_<DateTimeRange>(m, "SqpRange")
|
|
|
278
|
//.def("fromDateTime", &DateTimeRange::fromDateTime,
|
|
273
|
//.def("fromDateTime", &DateTimeRange::fromDateTime,
|
|
|
279
|
// py::return_value_policy::move)
|
|
274
|
// py::return_value_policy::move)
|
|
|
280
|
.def(py::init([](double start, double stop) {
|
|
275
|
.def(py::init([](double start, double stop) {
|
|
|
281
|
return DateTimeRange{start, stop};
|
|
276
|
return DateTimeRange{start, stop};
|
|
|
282
|
}))
|
|
277
|
}))
|
|
|
283
|
.def(py::init(
|
|
278
|
.def(py::init(
|
|
|
284
|
[](system_clock::time_point start, system_clock::time_point stop) {
|
|
279
|
[](system_clock::time_point start, system_clock::time_point stop) {
|
|
|
285
|
double start_ =
|
|
280
|
double start_ =
|
|
|
286
|
0.001 *
|
|
281
|
0.001 *
|
|
|
287
|
duration_cast<milliseconds>(start.time_since_epoch()).count();
|
|
282
|
duration_cast<milliseconds>(start.time_since_epoch()).count();
|
|
|
288
|
double stop_ =
|
|
283
|
double stop_ =
|
|
|
289
|
0.001 *
|
|
284
|
0.001 *
|
|
|
290
|
duration_cast<milliseconds>(stop.time_since_epoch()).count();
|
|
285
|
duration_cast<milliseconds>(stop.time_since_epoch()).count();
|
|
|
291
|
return DateTimeRange{start_, stop_};
|
|
286
|
return DateTimeRange{start_, stop_};
|
|
|
292
|
}))
|
|
287
|
}))
|
|
|
293
|
.def_property_readonly("start",
|
|
288
|
.def_property_readonly("start",
|
|
|
294
|
[](const DateTimeRange& range) {
|
|
289
|
[](const DateTimeRange& range) {
|
|
|
295
|
return system_clock::from_time_t(range.m_TStart);
|
|
290
|
return system_clock::from_time_t(range.m_TStart);
|
|
|
296
|
})
|
|
291
|
})
|
|
|
297
|
.def_property_readonly("stop",
|
|
292
|
.def_property_readonly("stop",
|
|
|
298
|
[](const DateTimeRange& range) {
|
|
293
|
[](const DateTimeRange& range) {
|
|
|
299
|
return system_clock::from_time_t(range.m_TEnd);
|
|
294
|
return system_clock::from_time_t(range.m_TEnd);
|
|
|
300
|
})
|
|
295
|
})
|
|
|
301
|
.def("__repr__", __repr__<DateTimeRange>);
|
|
296
|
.def("__repr__", __repr__<DateTimeRange>);
|
|
|
302
|
}
|
|
297
|
}
|
