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