##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » USERS » JEANDET » SciQLOPCore
RSS
Added Y log tag for Spectrograms...
jeandet -
r87:c6cf2dba079d
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,41 +1,43
1 #ifndef SCIQLOP_SPECTROGRAMTIMESERIE_H
1 #ifndef SCIQLOP_SPECTROGRAMTIMESERIE_H
2 #define SCIQLOP_SPECTROGRAMTIMESERIE_H
2 #define SCIQLOP_SPECTROGRAMTIMESERIE_H
3
3
4 #include "CoreGlobal.h"
4 #include "CoreGlobal.h"
5
5
6 #include <TimeSeries.h>
6 #include <TimeSeries.h>
7 #include <cmath>
7 #include <cmath>
8
8
9 class SCIQLOP_CORE_EXPORT SpectrogramTimeSerie
9 class SCIQLOP_CORE_EXPORT SpectrogramTimeSerie
10 : public TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>
10 : public TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>
11 {
11 {
12 public:
12 public:
13 double min_sampling = std::nan("");
13 double min_sampling = std::nan("");
14 double max_sampling = std::nan("");
14 double max_sampling = std::nan("");
15 bool y_is_log = true;
15 using item_t =
16 using item_t =
16 decltype(std::declval<
17 decltype(std::declval<
17 TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>>()[0]);
18 TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>>()[0]);
18
19
19 using iterator_t = decltype(
20 using iterator_t = decltype(
20 std::declval<TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>>()
21 std::declval<TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>>()
21 .begin());
22 .begin());
22
23
23 SpectrogramTimeSerie() {}
24 SpectrogramTimeSerie() {}
24 SpectrogramTimeSerie(SpectrogramTimeSerie::axis_t&& t,
25 SpectrogramTimeSerie(SpectrogramTimeSerie::axis_t&& t,
25 SpectrogramTimeSerie::axis_t&& y,
26 SpectrogramTimeSerie::axis_t&& y,
26 SpectrogramTimeSerie::container_type<
27 SpectrogramTimeSerie::container_type<
27 SpectrogramTimeSerie::raw_value_type>&& values,
28 SpectrogramTimeSerie::raw_value_type>&& values,
28 std::vector<std::size_t>& shape, double min_sampling,
29 std::vector<std::size_t>& shape, double min_sampling,
29 double max_sampling)
30 double max_sampling, bool y_is_log = true)
30 : TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>(t, values,
31 : TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>(t, values,
31 shape),
32 shape),
32 min_sampling{min_sampling}, max_sampling{max_sampling}
33 min_sampling{min_sampling}, max_sampling{max_sampling}, y_is_log{
34 y_is_log}
33 {
35 {
34 _axes[1] = y;
36 _axes[1] = y;
35 }
37 }
36
38
37 ~SpectrogramTimeSerie() = default;
39 ~SpectrogramTimeSerie() = default;
38 using TimeSerie::TimeSerie;
40 using TimeSerie::TimeSerie;
39 };
41 };
40
42
41 #endif // SCIQLOP_SPECTROGRAMTIMESERIE_H
43 #endif // SCIQLOP_SPECTROGRAMTIMESERIE_H
Show file before | Show file after | Hide comments
@@ -1,302 +1,302
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::container_type<VectorTimeSerie::raw_value_type>
177 _values(t.size());
177 _values(t.size());
178 copy_vector(t, values, _t, _values);
178 copy_vector(t, values, _t, _values);
179 return VectorTimeSerie(_t, _values);
179 return VectorTimeSerie(_t, _values);
180 }))
180 }))
181 .def(
181 .def(
182 "__getitem__",
182 "__getitem__",
183 [](VectorTimeSerie& ts, std::size_t key)
183 [](VectorTimeSerie& ts, std::size_t key)
184 -> VectorTimeSerie::raw_value_type& { return ts[key]; },
184 -> VectorTimeSerie::raw_value_type& { return ts[key]; },
185 py::return_value_policy::reference)
185 py::return_value_policy::reference)
186 .def("__setitem__", [](VectorTimeSerie& ts, std::size_t key,
186 .def("__setitem__", [](VectorTimeSerie& ts, std::size_t key,
187 VectorTimeSerie::raw_value_type value) {
187 VectorTimeSerie::raw_value_type value) {
188 *(ts.begin() + key) = value;
188 *(ts.begin() + key) = value;
189 });
189 });
190
190
191 py::class_<MultiComponentTimeSerie::iterator_t>(m,
191 py::class_<MultiComponentTimeSerie::iterator_t>(m,
192 "MultiComponentTimeSerieItem")
192 "MultiComponentTimeSerieItem")
193 .def("__getitem__", [](MultiComponentTimeSerie::iterator_t& self,
193 .def("__getitem__", [](MultiComponentTimeSerie::iterator_t& self,
194 std::size_t key) { return (*self)[key]; })
194 std::size_t key) { return (*self)[key]; })
195 .def("__setitem__",
195 .def("__setitem__",
196 [](MultiComponentTimeSerie::iterator_t& self, std::size_t key,
196 [](MultiComponentTimeSerie::iterator_t& self, std::size_t key,
197 double value) { (*self)[key] = value; });
197 double value) { (*self)[key] = value; });
198
198
199 py::class_<MultiComponentTimeSerie, TimeSeries::ITimeSerie,
199 py::class_<MultiComponentTimeSerie, TimeSeries::ITimeSerie,
200 std::shared_ptr<MultiComponentTimeSerie>>(
200 std::shared_ptr<MultiComponentTimeSerie>>(
201 m, "MultiComponentTimeSerie")
201 m, "MultiComponentTimeSerie")
202 .def(py::init<>())
202 .def(py::init<>())
203 .def(py::init<const std::vector<std::size_t>>())
203 .def(py::init<const std::vector<std::size_t>>())
204 .def(py::init([](py::array_t<double> t, py::array_t<double> values) {
204 .def(py::init([](py::array_t<double> t, py::array_t<double> values) {
205 assert((t.size() < values.size()) |
205 assert((t.size() < values.size()) |
206 (t.size() == 0)); // TODO check geometry
206 (t.size() == 0)); // TODO check geometry
207 MultiComponentTimeSerie::axis_t _t(t.size());
207 MultiComponentTimeSerie::axis_t _t(t.size());
208 MultiComponentTimeSerie::container_type<
208 MultiComponentTimeSerie::container_type<
209 MultiComponentTimeSerie::raw_value_type>
209 MultiComponentTimeSerie::raw_value_type>
210 _values(values.size());
210 _values(values.size());
211 copy_multicomp(t, values, _t, _values);
211 copy_multicomp(t, values, _t, _values);
212 std::vector<std::size_t> shape;
212 std::vector<std::size_t> shape;
213 shape.push_back(values.shape(0));
213 shape.push_back(values.shape(0));
214 shape.push_back(values.shape(1));
214 shape.push_back(values.shape(1));
215 return MultiComponentTimeSerie(_t, _values, shape);
215 return MultiComponentTimeSerie(_t, _values, shape);
216 }))
216 }))
217 .def("__getitem__",
217 .def("__getitem__",
218 [](MultiComponentTimeSerie& ts,
218 [](MultiComponentTimeSerie& ts,
219 std::size_t key) -> MultiComponentTimeSerie::iterator_t {
219 std::size_t key) -> MultiComponentTimeSerie::iterator_t {
220 return ts.begin() + key;
220 return ts.begin() + key;
221 });
221 });
222
222
223 py::class_<SpectrogramTimeSerie::iterator_t>(m, "SpectrogramTimeSerieItem")
223 py::class_<SpectrogramTimeSerie::iterator_t>(m, "SpectrogramTimeSerieItem")
224 .def("__getitem__", [](SpectrogramTimeSerie::iterator_t& self,
224 .def("__getitem__", [](SpectrogramTimeSerie::iterator_t& self,
225 std::size_t key) { return (*self)[key]; })
225 std::size_t key) { return (*self)[key]; })
226 .def("__setitem__",
226 .def("__setitem__",
227 [](SpectrogramTimeSerie::iterator_t& self, std::size_t key,
227 [](SpectrogramTimeSerie::iterator_t& self, std::size_t key,
228 double value) { (*self)[key] = value; });
228 double value) { (*self)[key] = value; });
229
229
230 py::class_<SpectrogramTimeSerie, TimeSeries::ITimeSerie,
230 py::class_<SpectrogramTimeSerie, TimeSeries::ITimeSerie,
231 std::shared_ptr<SpectrogramTimeSerie>>(m, "SpectrogramTimeSerie")
231 std::shared_ptr<SpectrogramTimeSerie>>(m, "SpectrogramTimeSerie")
232 .def(py::init<>())
232 .def(py::init<>())
233 .def(py::init<const std::vector<std::size_t>>())
233 .def(py::init<const std::vector<std::size_t>>())
234 .def(py::init([](py::array_t<double> t, py::array_t<double> y,
234 .def(py::init([](py::array_t<double> t, py::array_t<double> y,
235 py::array_t<double> values, double min_sampling,
235 py::array_t<double> values, double min_sampling,
236 double max_sampling) {
236 double max_sampling, bool y_is_log) {
237 if(t.size() >= values.size() and t.size() != 0)
237 if(t.size() >= values.size() and t.size() != 0)
238 SCIQLOP_ERROR(decltype(py::self), "Doesn't look like a Spectrogram");
238 SCIQLOP_ERROR(decltype(py::self), "Doesn't look like a Spectrogram");
239 if(y.size() != values.shape(1))
239 if(y.size() != values.shape(1))
240 SCIQLOP_ERROR(decltype(py::self),
240 SCIQLOP_ERROR(decltype(py::self),
241 "Y axis size and data shape are incompatible");
241 "Y axis size and data shape are incompatible");
242 SpectrogramTimeSerie::axis_t _t(t.size());
242 SpectrogramTimeSerie::axis_t _t(t.size());
243 SpectrogramTimeSerie::axis_t _y(y.size());
243 SpectrogramTimeSerie::axis_t _y(y.size());
244 SpectrogramTimeSerie::container_type<
244 SpectrogramTimeSerie::container_type<
245 SpectrogramTimeSerie::raw_value_type>
245 SpectrogramTimeSerie::raw_value_type>
246 _values(values.size());
246 _values(values.size());
247 copy_spectro(t, y, values, _t, _y, _values);
247 copy_spectro(t, y, values, _t, _y, _values);
248 std::vector<std::size_t> shape;
248 std::vector<std::size_t> shape;
249 shape.push_back(values.shape(0));
249 shape.push_back(values.shape(0));
250 shape.push_back(values.shape(1));
250 shape.push_back(values.shape(1));
251 return SpectrogramTimeSerie(std::move(_t), std::move(_y),
251 return SpectrogramTimeSerie(std::move(_t), std::move(_y),
252 std::move(_values), shape, min_sampling,
252 std::move(_values), shape, min_sampling,
253 max_sampling);
253 max_sampling, y_is_log);
254 }))
254 }))
255 .def("__getitem__",
255 .def("__getitem__",
256 [](SpectrogramTimeSerie& ts,
256 [](SpectrogramTimeSerie& ts,
257 std::size_t key) -> SpectrogramTimeSerie::iterator_t {
257 std::size_t key) -> SpectrogramTimeSerie::iterator_t {
258 return ts.begin() + key;
258 return ts.begin() + key;
259 });
259 });
260
260
261 py::class_<Variable2, std::shared_ptr<Variable2>>(m, "Variable2")
261 py::class_<Variable2, std::shared_ptr<Variable2>>(m, "Variable2")
262 .def(py::init<const QString&>())
262 .def(py::init<const QString&>())
263 .def_property("name", &Variable2::name, &Variable2::setName)
263 .def_property("name", &Variable2::name, &Variable2::setName)
264 .def_property_readonly("range", &Variable2::range)
264 .def_property_readonly("range", &Variable2::range)
265 .def_property_readonly("nbPoints", &Variable2::nbPoints)
265 .def_property_readonly("nbPoints", &Variable2::nbPoints)
266 .def_property_readonly(
266 .def_property_readonly(
267 "data",
267 "data",
268 [](Variable2& var) -> std::shared_ptr<TimeSeries::ITimeSerie> {
268 [](Variable2& var) -> std::shared_ptr<TimeSeries::ITimeSerie> {
269 return var.data();
269 return var.data();
270 })
270 })
271 .def("set_data",
271 .def("set_data",
272 [](Variable2& var, std::vector<TimeSeries::ITimeSerie*> ts_list,
272 [](Variable2& var, std::vector<TimeSeries::ITimeSerie*> ts_list,
273 const DateTimeRange& range) { var.setData(ts_list, range); })
273 const DateTimeRange& range) { var.setData(ts_list, range); })
274 .def("__len__", &Variable2::nbPoints)
274 .def("__len__", &Variable2::nbPoints)
275 .def("__repr__", __repr__<Variable2>);
275 .def("__repr__", __repr__<Variable2>);
276
276
277 py::class_<DateTimeRange>(m, "SqpRange")
277 py::class_<DateTimeRange>(m, "SqpRange")
278 //.def("fromDateTime", &DateTimeRange::fromDateTime,
278 //.def("fromDateTime", &DateTimeRange::fromDateTime,
279 // py::return_value_policy::move)
279 // py::return_value_policy::move)
280 .def(py::init([](double start, double stop) {
280 .def(py::init([](double start, double stop) {
281 return DateTimeRange{start, stop};
281 return DateTimeRange{start, stop};
282 }))
282 }))
283 .def(py::init(
283 .def(py::init(
284 [](system_clock::time_point start, system_clock::time_point stop) {
284 [](system_clock::time_point start, system_clock::time_point stop) {
285 double start_ =
285 double start_ =
286 0.001 *
286 0.001 *
287 duration_cast<milliseconds>(start.time_since_epoch()).count();
287 duration_cast<milliseconds>(start.time_since_epoch()).count();
288 double stop_ =
288 double stop_ =
289 0.001 *
289 0.001 *
290 duration_cast<milliseconds>(stop.time_since_epoch()).count();
290 duration_cast<milliseconds>(stop.time_since_epoch()).count();
291 return DateTimeRange{start_, stop_};
291 return DateTimeRange{start_, stop_};
292 }))
292 }))
293 .def_property_readonly("start",
293 .def_property_readonly("start",
294 [](const DateTimeRange& range) {
294 [](const DateTimeRange& range) {
295 return system_clock::from_time_t(range.m_TStart);
295 return system_clock::from_time_t(range.m_TStart);
296 })
296 })
297 .def_property_readonly("stop",
297 .def_property_readonly("stop",
298 [](const DateTimeRange& range) {
298 [](const DateTimeRange& range) {
299 return system_clock::from_time_t(range.m_TEnd);
299 return system_clock::from_time_t(range.m_TEnd);
300 })
300 })
301 .def("__repr__", __repr__<DateTimeRange>);
301 .def("__repr__", __repr__<DateTimeRange>);
302 }
302 }
General Comments 0
You need to be logged in to leave comments. Login now