##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » USERS » JEANDET » SciQLOPCore
RSS
Mostly working Spectrograms...
jeandet -
r84:483146a07a5f
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,32 +1,33
1 1 #!/usr/bin/env python3
2 2
3 3 from dumper import *
4 4
5 5 import sys
6 6 import os
7 7 import numpy as np
8 8 import datetime
9 9 import time
10 10
11 11
12 12 def qdump__DateTimeRange(d , value):
13 13 """
14 14
15 15 :param d: DumperBase
16 16 :param value: Value
17 17 """
18 18 tstart = datetime.datetime.utcfromtimestamp(value['m_TStart'].to('d'))
19 19 tstop = datetime.datetime.utcfromtimestamp(value['m_TEnd'].to('d'))
20 20 delta = str(tstop - tstart)
21 21 tstart, tstop = str(tstart), str(tstop)
22 22
23 23 d.putValue(tstart + ' : ' + tstop)
24 24 d.putNumChild(3)
25 25 if d.isExpanded():
26 26 with Children(d, 3):
27 27 with SubItem(d, "start"):
28 28 d.putValue(tstart)
29 29 with SubItem(d, "stop"):
30 30 d.putValue(tstop)
31 31 with SubItem(d, "delta"):
32 32 d.putValue(delta)
33
Show file before | Show file after | Hide comments
@@ -1,1 +1,1
1 Subproject commit f5f4debc597b41ab1849dfc02b6e092bf58c32d2
1 Subproject commit 22e3e4553178230053aac40131b4fdb36c163075
Show file before | Show file after | Hide comments
@@ -1,29 +1,37
1 1 #ifndef CPP_UTILS_H
2 2 #define CPP_UTILS_H
3 3
4 #include <functional>
5 #include <tuple>
4 6 #include <type_traits>
5 7
6 template< class... >
7 using void_t = void;
8 template<class...> using void_t = void;
8 9
9 10 #define HAS_METHOD(method)\
10 template <class T, class=void>\
11 struct _has_##method : std::false_type{};\
11 template<class T, class = void> struct _has_##method : std::false_type \
12 {}; \
12 13 \
13 14 template <class T>\
14 struct _has_##method<T, void_t<std::is_member_function_pointer<decltype(&T::method)>>>\
15 : std::true_type{};\
15 struct _has_##method< \
16 T, void_t<std::is_member_function_pointer<decltype(&T::method)>>> \
17 : std::true_type \
18 {}; \
16 19 \
17 20 template< class T>\
18 21 static inline constexpr bool has_##method = _has_##method<T>::value;
19 22
20 23 //taken from here https://www.fluentcpp.com/2017/10/27/function-aliases-cpp/
21 24 #define ALIAS_TEMPLATE_FUNCTION(highLevelF, lowLevelF) \
22 25 template <typename... Args> \
23 inline auto highLevelF(Args &&... args)->decltype(lowLevelF(std::forward<Args>(args)...)) \
26 inline auto highLevelF(Args&&... args) \
27 ->decltype(lowLevelF(std::forward<Args>(args)...)) \
24 28 { \
25 29 return lowLevelF(std::forward<Args>(args)...); \
26 30 }
27 31
32 template<typename T> constexpr T diff(const std::pair<T, T>& p)
33 {
34 return p.second - p.first;
35 }
28 36
29 37 #endif // CPP_UTILS_H
Show file before | Show file after | Hide comments
@@ -1,35 +1,35
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
8 8 class SCIQLOP_CORE_EXPORT SpectrogramTimeSerie
9 9 : public TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>
10 10 {
11 11 public:
12 12 using item_t =
13 13 decltype(std::declval<
14 14 TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>>()[0]);
15 15
16 16 using iterator_t = decltype(
17 17 std::declval<TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>>()
18 18 .begin());
19 19
20 20 SpectrogramTimeSerie() {}
21 SpectrogramTimeSerie(SpectrogramTimeSerie::axis_t& t,
22 SpectrogramTimeSerie::axis_t& y,
21 SpectrogramTimeSerie(SpectrogramTimeSerie::axis_t&& t,
22 SpectrogramTimeSerie::axis_t&& y,
23 23 SpectrogramTimeSerie::container_type<
24 SpectrogramTimeSerie::raw_value_type>& values,
24 SpectrogramTimeSerie::raw_value_type>&& values,
25 25 std::vector<std::size_t>& shape)
26 26 : TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>(t, values, shape)
27 27 {
28 28 _axes[1] = y;
29 29 }
30 30
31 31 ~SpectrogramTimeSerie() = default;
32 32 using TimeSerie::TimeSerie;
33 33 };
34 34
35 35 #endif // SCIQLOP_SPECTROGRAMTIMESERIE_H
Show file before | Show file after | Hide comments
@@ -1,41 +1,83
1 1 #ifndef TIMESERIESUTILS_H
2 2 #define TIMESERIESUTILS_H
3 3 #include "MultiComponentTimeSerie.h"
4 4 #include "ScalarTimeSerie.h"
5 5 #include "SpectrogramTimeSerie.h"
6 6 #include "VectorTimeSerie.h"
7 7
8 8 #include <TimeSeries.h>
9 #include <cmath>
9 10 #include <memory>
10 11
11 12 namespace TimeSeriesUtils
12 13 {
13 14 template<typename T> TimeSeries::ITimeSerie* copy(T input_ts)
14 15 {
15 16 if constexpr(std::is_base_of_v<TimeSeries::ITimeSerie, T>)
16 17 {
17 18 if(auto ts = dynamic_cast<VectorTimeSerie*>(input_ts))
18 19 { return new VectorTimeSerie(*ts); }
19 20 if(auto ts = dynamic_cast<ScalarTimeSerie*>(input_ts))
20 21 { return new ScalarTimeSerie(*ts); }
21 22 if(auto ts = dynamic_cast<MultiComponentTimeSerie*>(input_ts))
22 23 { return new MultiComponentTimeSerie(*ts); }
23 24 if(auto ts = dynamic_cast<SpectrogramTimeSerie*>(input_ts))
24 25 { return new SpectrogramTimeSerie(*ts); }
25 26 }
26 27 else
27 28 {
28 29 if(auto ts = std::dynamic_pointer_cast<VectorTimeSerie>(input_ts))
29 30 { return new VectorTimeSerie(*ts); }
30 31 if(auto ts = std::dynamic_pointer_cast<ScalarTimeSerie>(input_ts))
31 32 { return new ScalarTimeSerie(*ts); }
32 33 if(auto ts = std::dynamic_pointer_cast<SpectrogramTimeSerie>(input_ts))
33 34 { return new SpectrogramTimeSerie(*ts); }
34 35 if(auto ts = std::dynamic_pointer_cast<MultiComponentTimeSerie>(input_ts))
35 36 { return new MultiComponentTimeSerie(*ts); }
36 37 }
37 38 return nullptr;
38 39 }
40
41 struct axis_properties
42 {
43 double range;
44 double max_resolution;
45 bool is_log;
46 };
47
48 constexpr auto IsLog = true;
49 constexpr auto IsLinear = false;
50
51 constexpr auto CheckMedian = true;
52 constexpr auto DontCheckMedian = false;
53
54 template<bool is_log, bool check_median>
55 axis_properties axis_analysis(
56 typename std::conditional<is_log, std::vector<double>&,
57 const std::vector<double>&>::type axis)
58 {
59 std::vector<double> axis_diff(axis.size());
60 if constexpr(is_log)
61 {
62 std::transform(std::cbegin(axis), std::cend(axis), std::begin(axis),
63 [](const auto v) { return std::log10(v); });
64 }
65 auto range = *(std::cend(axis) - 1) - *(std::begin(axis));
66 std::adjacent_difference(std::cbegin(axis), std::cend(axis),
67 std::begin(axis_diff));
68 auto min_diff =
69 (*std::min_element(std::cbegin(axis_diff) + 1, std::cend(axis_diff)));
70 if constexpr(check_median)
71 {
72 std::nth_element(std::begin(axis_diff) + 1,
73 std::begin(axis_diff) + axis_diff.size() / 2,
74 std::end(axis_diff));
75 auto median_diff = *(std::begin(axis_diff) + axis_diff.size() / 2);
76 if(median_diff > (4 * min_diff)) min_diff = median_diff;
77 }
78 return {range, min_diff, is_log};
79 }
80
39 81 } // namespace TimeSeriesUtils
40 82
41 83 #endif
Show file before | Show file after | Hide comments
@@ -1,226 +1,236
1 1 #include "Variable/Variable2.h"
2 2
3 3 #define PROPERTY_(property, getter, setter, type) \
4 4 type getter() noexcept \
5 5 { \
6 6 QReadLocker lock{&m_Lock}; \
7 7 return property; \
8 8 } \
9 9 void setter(const type& getter) noexcept \
10 10 { \
11 11 QWriteLocker lock{&m_Lock}; \
12 12 property = getter; \
13 13 } \
14 14 type property;
15 15
16 16 #define V_FW_GETTER_SETTER(getter, setter, type) \
17 17 type Variable2::getter() \
18 18 { \
19 19 QReadLocker lock{&this->m_lock}; \
20 20 return impl->getter(); \
21 21 } \
22 22 void Variable2::setter(const type& value) \
23 23 { \
24 24 { \
25 25 QWriteLocker lock{&this->m_lock}; \
26 26 impl->setter(value); \
27 27 } \
28 28 emit updated(this->ID()); \
29 29 }
30 30
31 31 static DataSeriesType findDataSeriesType(const QVariantHash& metadata)
32 32 {
33 33 auto dataSeriesType = DataSeriesType::NONE;
34 34
35 35 // Go through the metadata and stop at the first value that could be converted
36 36 // to DataSeriesType
37 37 for(auto it = metadata.cbegin(), end = metadata.cend();
38 38 it != end && dataSeriesType == DataSeriesType::NONE; ++it)
39 39 {
40 40 dataSeriesType = DataSeriesTypeUtils::fromString(it.value().toString());
41 41 }
42 42
43 43 return dataSeriesType;
44 44 }
45 45
46 46 std::shared_ptr<TimeSeries::ITimeSerie>
47 47 clone_ts(const std::shared_ptr<TimeSeries::ITimeSerie>& ts)
48 48 {
49 49 if(auto scal_ts = std::dynamic_pointer_cast<ScalarTimeSerie>(ts))
50 50 return std::make_shared<ScalarTimeSerie>(*scal_ts);
51 51 if(auto scal_ts = std::dynamic_pointer_cast<VectorTimeSerie>(ts))
52 52 return std::make_shared<VectorTimeSerie>(*scal_ts);
53 53 if(auto scal_ts = std::dynamic_pointer_cast<SpectrogramTimeSerie>(ts))
54 54 return std::make_shared<SpectrogramTimeSerie>(*scal_ts);
55 55 return nullptr;
56 56 }
57 57
58 58 struct Variable2::VariablePrivate
59 59 {
60 60 VariablePrivate(const QString& name, const QVariantHash& metadata)
61 61 : m_Name{name}, m_Range{INVALID_RANGE}, m_Metadata{metadata}, m_TimeSerie{
62 62 nullptr}
63 63 {
64 64 switch(findDataSeriesType(metadata))
65 65 {
66 66 case DataSeriesType::SCALAR:
67 67 m_TimeSerie = std::make_shared<ScalarTimeSerie>(ScalarTimeSerie{});
68 68 break;
69 69 case DataSeriesType::VECTOR:
70 70 m_TimeSerie = std::make_shared<VectorTimeSerie>(VectorTimeSerie{});
71 71 break;
72 72 case DataSeriesType::SPECTROGRAM:
73 73 m_TimeSerie =
74 74 std::make_shared<SpectrogramTimeSerie>(SpectrogramTimeSerie{});
75 75 break;
76 76 case DataSeriesType::MULTICOMPONENT:
77 77 {
78 78 std::size_t count = metadata.value(QString("size"), 0).toInt();
79 79 m_TimeSerie = std::make_shared<MultiComponentTimeSerie>(
80 80 MultiComponentTimeSerie{{0, count}});
81 81 }
82 82 break;
83 83 default: break;
84 84 }
85 85 }
86 86
87 87 VariablePrivate(const VariablePrivate& other)
88 88 : m_Name{other.m_Name}, m_Range{other.m_Range},
89 89 m_Metadata{other.m_Metadata}, m_RealRange{other.m_RealRange}
90 90 {
91 91 m_TimeSerie = clone_ts(other.m_TimeSerie);
92 92 }
93 93
94 94 std::size_t nbPoints()
95 95 {
96 96 if(m_TimeSerie) return m_TimeSerie->size();
97 97 return 0;
98 98 }
99 99 DataSeriesType type() const
100 100 {
101 101 return DataSeriesTypeUtils::type(m_TimeSerie.get());
102 102 }
103 103
104 104 PROPERTY_(m_Name, name, setName, QString)
105 105 PROPERTY_(m_Range, range, setRange, DateTimeRange)
106 106 PROPERTY_(m_Metadata, metadata, setMetadata, QVariantHash)
107 107 PROPERTY_(m_RealRange, realRange, setRealRange, std::optional<DateTimeRange>)
108 108 std::shared_ptr<TimeSeries::ITimeSerie> dataSeries() { return m_TimeSerie; }
109 109 void setDataSeries(std::shared_ptr<TimeSeries::ITimeSerie>&& timeSerie)
110 110 {
111 111 QWriteLocker lock{&m_Lock};
112 112 m_TimeSerie = timeSerie;
113 113 if(m_TimeSerie) { setRealRange(DateTimeRange(m_TimeSerie->axis_range(0))); }
114 114 else
115 115 {
116 116 setRealRange(std::nullopt);
117 117 }
118 118 }
119 119 std::shared_ptr<TimeSeries::ITimeSerie> m_TimeSerie;
120 120 QReadWriteLock m_Lock{QReadWriteLock::Recursive};
121 121 };
122 122
123 123 Variable2::Variable2(const QString& name, const QVariantHash& metadata)
124 124 : impl{spimpl::make_unique_impl<VariablePrivate>(name, metadata)},
125 125 _uuid{QUuid::createUuid()}
126 126 {}
127 127
128 128 Variable2::Variable2(const Variable2& other)
129 129 : impl{spimpl::make_unique_impl<VariablePrivate>(*other.impl)},
130 130 _uuid{QUuid::createUuid()} // is a clone but must have a != uuid
131 131 {}
132 132
133 133 std::shared_ptr<Variable2> Variable2::clone() const
134 134 {
135 135 return std::make_shared<Variable2>(*this);
136 136 }
137 137
138 138 V_FW_GETTER_SETTER(name, setName, QString)
139 139
140 140 DateTimeRange Variable2::range() { return impl->range(); }
141 141
142 142 void Variable2::setRange(const DateTimeRange& range)
143 143 {
144 144 QWriteLocker lock{&m_lock};
145 145 impl->setRange(range);
146 146 }
147 147
148 148 std::optional<DateTimeRange> Variable2::realRange()
149 149 {
150 150 QReadLocker lock{&m_lock};
151 151 return impl->realRange();
152 152 }
153 153
154 154 std::size_t Variable2::nbPoints() { return impl->nbPoints(); }
155 155
156 156 std::shared_ptr<TimeSeries::ITimeSerie> Variable2::data()
157 157 {
158 158 return impl->dataSeries();
159 159 }
160 160
161 161 DataSeriesType Variable2::type()
162 162 {
163 163 QReadLocker lock{&m_lock};
164 164 return impl->type();
165 165 }
166 166
167 167 QVariantHash Variable2::metadata() const noexcept { return impl->metadata(); }
168 168
169 169 template<typename T>
170 170 std::shared_ptr<TimeSeries::ITimeSerie>
171 171 _merge(std::vector<TimeSeries::ITimeSerie*> source, const DateTimeRange& range)
172 172 {
173 173 std::sort(std::begin(source), std::end(source),
174 174 [](TimeSeries::ITimeSerie* a, TimeSeries::ITimeSerie* b) {
175 175 if(a->size() && b->size()) return a->t(0) < b->t(0);
176 176 return false;
177 177 });
178 178 std::shared_ptr<TimeSeries::ITimeSerie> dest = std::make_shared<T>();
179 179 std::for_each(
180 180 std::begin(source), std::end(source),
181 181 [&dest, &range](TimeSeries::ITimeSerie* serie) {
182 182 auto& ts = *static_cast<T*>(serie);
183 183 auto last_t = range.m_TStart;
184 184 if(dest->size()) last_t = dest->axis(0).back();
185 185 if(ts.size())
186 186 {
187 187 std::copy(std::upper_bound(
188 188 std::begin(ts), std::end(ts), last_t,
189 189 [](const auto& a, const auto& b) { return a < b.t(); }),
190 190 std::lower_bound(
191 191 std::begin(ts), std::end(ts), range.m_TEnd,
192 192 [](const auto& a, const auto& b) { return a.t() < b; }),
193 193 std::back_inserter(*std::dynamic_pointer_cast<T>(dest)));
194 194 }
195 195 });
196 if(source.size())
197 {
198 const auto& first = *source.begin();
199 for(std::size_t ax_index = 1; ax_index < first->shape().size(); ax_index++)
200 {
201 const auto& ax = first->axis(ax_index);
202 std::copy(std::cbegin(ax), std::cend(ax),
203 std::back_inserter(dest->axis(ax_index)));
204 }
205 }
196 206 return dest;
197 207 }
198 208
199 209 std::shared_ptr<TimeSeries::ITimeSerie>
200 210 merge(const std::vector<TimeSeries::ITimeSerie*>& dataSeries,
201 211 const DateTimeRange& range)
202 212 {
203 213 if(dynamic_cast<ScalarTimeSerie*>(dataSeries.front()))
204 214 return _merge<ScalarTimeSerie>(dataSeries, range);
205 215 if(dynamic_cast<VectorTimeSerie*>(dataSeries.front()))
206 216 return _merge<VectorTimeSerie>(dataSeries, range);
207 217 if(dynamic_cast<MultiComponentTimeSerie*>(dataSeries.front()))
208 218 return _merge<MultiComponentTimeSerie>(dataSeries, range);
209 219 if(dynamic_cast<SpectrogramTimeSerie*>(dataSeries.front()))
210 220 return _merge<SpectrogramTimeSerie>(dataSeries, range);
211 221 return std::shared_ptr<TimeSeries::ITimeSerie>{};
212 222 }
213 223
214 224 void Variable2::setData(const std::vector<TimeSeries::ITimeSerie*>& dataSeries,
215 225 const DateTimeRange& range, bool notify)
216 226 {
217 227 if(dataSeries.size())
218 228 {
219 229 {
220 230 QWriteLocker lock{&m_lock};
221 231 impl->setDataSeries(merge(dataSeries, range));
222 232 impl->setRange(range);
223 233 }
224 234 if(notify) emit this->updated(this->ID());
225 235 }
226 236 }
Show file before | Show file after | Hide comments
@@ -1,295 +1,299
1 1 #include "CoreWrappers.h"
2 2
3 3 #include "pywrappers_common.h"
4 4
5 5 #include <Data/DataSeriesType.h>
6 6 #include <Data/IDataProvider.h>
7 7 #include <Network/Downloader.h>
8 8 #include <Time/TimeController.h>
9 9 #include <Variable/Variable2.h>
10 10 #include <Variable/VariableController2.h>
11 11 #include <pybind11/chrono.h>
12 12 #include <pybind11/embed.h>
13 13 #include <pybind11/functional.h>
14 14 #include <pybind11/numpy.h>
15 15 #include <pybind11/operators.h>
16 16 #include <pybind11/pybind11.h>
17 17 #include <pybind11/stl.h>
18 18 #include <pybind11/stl_bind.h>
19 19 #include <sstream>
20 20 #include <string>
21 21
22 22 namespace py = pybind11;
23 23 using namespace std::chrono;
24 24
25 25 template<typename T, typename U, bool row_major = true>
26 26 void copy_vector(py::array_t<double>& t, py::array_t<double>& values, T& dest_t,
27 27 U& dest_values)
28 28 {
29 29 auto t_view = t.unchecked<1>();
30 30 auto values_view = values.unchecked<2>();
31 31 for(std::size_t i = 0; i < t.size(); i++)
32 32 {
33 33 dest_t[i] = t_view[i];
34 34 dest_values[i] = {values_view(i, 0), values_view(i, 1), values_view(i, 2)};
35 35 }
36 36 }
37 37
38 38 template<typename T, typename U>
39 39 void copy_scalar(py::array_t<double>& t, py::array_t<double>& values, T& dest_t,
40 40 U& dest_values)
41 41 {
42 42 auto t_view = t.unchecked<1>();
43 43 if(values.ndim() == 1)
44 44 {
45 45 auto values_view = values.unchecked<1>();
46 46 for(std::size_t i = 0; i < t.size(); i++)
47 47 {
48 48 dest_t[i] = t_view[i];
49 49 dest_values[i] = values_view[i];
50 50 }
51 51 }
52 52 else if(values.ndim() == 2 && values.shape(1) == 1)
53 53 {
54 54 auto values_view = values.unchecked<2>();
55 55 for(std::size_t i = 0; i < t.size(); i++)
56 56 {
57 57 dest_t[i] = t_view[i];
58 58 dest_values[i] = values_view(i, 0);
59 59 }
60 60 }
61 61 }
62 62 template<typename T, typename U>
63 63 void copy_multicomp(py::array_t<double>& t, py::array_t<double>& values,
64 64 T& dest_t, U& dest_values)
65 65 {
66 66 auto t_view = t.unchecked<1>();
67 67 auto values_view = values.unchecked<2>();
68 68 const auto width = values.shape(1);
69 69 for(std::size_t i = 0; i < t.size(); i++)
70 70 {
71 71 dest_t[i] = t_view[i];
72 72 for(int j = 0; j < width; j++)
73 73 {
74 74 dest_values[i * width + j] = values_view(i, j);
75 75 }
76 76 }
77 77 }
78 78
79 79 template<typename T, typename U>
80 80 void copy_spectro(py::array_t<double>& t, py::array_t<double>& y,
81 81 py::array_t<double>& values, T& dest_t, T& dest_y,
82 82 U& dest_values)
83 83 {
84 84 auto t_view = t.unchecked<1>();
85 85 auto y_view = y.unchecked<1>();
86 86 auto values_view = values.unchecked<2>();
87 87 const auto width = values.shape(1);
88 88 for(std::size_t i = 0; i < y.size(); i++)
89 89 {
90 90 dest_y[i] = y_view[i];
91 91 }
92 92 for(std::size_t i = 0; i < t.size(); i++)
93 93 {
94 94 dest_t[i] = t_view[i];
95 95 for(int j = 0; j < width; j++)
96 96 {
97 97 dest_values[i * width + j] = values_view(i, j);
98 98 }
99 99 }
100 100 }
101 101
102 102 PYBIND11_MODULE(pysciqlopcore, m)
103 103 {
104 104 pybind11::bind_vector<std::vector<double>>(m, "VectorDouble");
105 105
106 106 py::enum_<DataSeriesType>(m, "DataSeriesType")
107 107 .value("SCALAR", DataSeriesType::SCALAR)
108 108 .value("SPECTROGRAM", DataSeriesType::SPECTROGRAM)
109 109 .value("VECTOR", DataSeriesType::VECTOR)
110 110 .value("MULTICOMPONENT", DataSeriesType::MULTICOMPONENT)
111 111 .value("NONE", DataSeriesType::NONE)
112 112 .export_values();
113 113
114 114 py::class_<Response>(m, "Response")
115 115 .def("status_code", &Response::status_code);
116 116
117 117 py::class_<Downloader>(m, "Downloader")
118 118 .def_static("get", Downloader::get)
119 119 .def_static("getAsync", Downloader::getAsync)
120 120 .def_static("downloadFinished", Downloader::downloadFinished);
121 121
122 122 py::class_<IDataProvider, std::shared_ptr<IDataProvider>>(m, "IDataProvider");
123 123
124 124 py::class_<TimeSeries::ITimeSerie, std::shared_ptr<TimeSeries::ITimeSerie>>(
125 125 m, "ITimeSerie")
126 126 .def_property_readonly(
127 127 "size", [](const TimeSeries::ITimeSerie& ts) { return ts.size(); })
128 128 .def("__len__",
129 129 [](const TimeSeries::ITimeSerie& ts) { return ts.size(); })
130 130 .def_property_readonly(
131 131 "shape", [](const TimeSeries::ITimeSerie& ts) { return ts.shape(); })
132 132 .def_property_readonly(
133 133 "t",
134 134 [](TimeSeries::ITimeSerie& ts) -> decltype(ts.axis(0))& {
135 135 return ts.axis(0);
136 136 },
137 137 py::return_value_policy::reference)
138 138 .def(
139 139 "axis",
140 140 [](TimeSeries::ITimeSerie& ts, unsigned int index)
141 141 -> decltype(ts.axis(0))& { return ts.axis(index); },
142 142 py::return_value_policy::reference);
143 143
144 144 py::class_<ScalarTimeSerie, TimeSeries::ITimeSerie,
145 145 std::shared_ptr<ScalarTimeSerie>>(m, "ScalarTimeSerie")
146 146 .def(py::init<>())
147 147 .def(py::init<std::size_t>())
148 148 .def(py::init([](py::array_t<double> t, py::array_t<double> values) {
149 149 assert(t.size() == values.size());
150 150 ScalarTimeSerie::axis_t _t(t.size());
151 151 ScalarTimeSerie::axis_t _values(t.size());
152 152 copy_scalar(t, values, _t, _values);
153 153 return ScalarTimeSerie(_t, _values);
154 154 }))
155 155 .def("__getitem__",
156 156 [](ScalarTimeSerie& ts, std::size_t key) { return ts[key]; })
157 157 .def("__setitem__", [](ScalarTimeSerie& ts, std::size_t key,
158 158 double value) { *(ts.begin() + key) = value; });
159 159
160 160 py::class_<VectorTimeSerie::raw_value_type>(m, "vector")
161 161 .def(py::init<>())
162 162 .def(py::init<double, double, double>())
163 163 .def("__repr__", __repr__<VectorTimeSerie::raw_value_type>)
164 164 .def_readwrite("x", &VectorTimeSerie::raw_value_type::x)
165 165 .def_readwrite("y", &VectorTimeSerie::raw_value_type::y)
166 166 .def_readwrite("z", &VectorTimeSerie::raw_value_type::z);
167 167
168 168 py::class_<VectorTimeSerie, TimeSeries::ITimeSerie,
169 169 std::shared_ptr<VectorTimeSerie>>(m, "VectorTimeSerie")
170 170 .def(py::init<>())
171 171 .def(py::init<std::size_t>())
172 172 .def(py::init([](py::array_t<double> t, py::array_t<double> values) {
173 173 assert(t.size() * 3 == values.size());
174 174 VectorTimeSerie::axis_t _t(t.size());
175 175 VectorTimeSerie::container_type<VectorTimeSerie::raw_value_type>
176 176 _values(t.size());
177 177 copy_vector(t, values, _t, _values);
178 178 return VectorTimeSerie(_t, _values);
179 179 }))
180 180 .def(
181 181 "__getitem__",
182 182 [](VectorTimeSerie& ts, std::size_t key)
183 183 -> VectorTimeSerie::raw_value_type& { return ts[key]; },
184 184 py::return_value_policy::reference)
185 185 .def("__setitem__", [](VectorTimeSerie& ts, std::size_t key,
186 186 VectorTimeSerie::raw_value_type value) {
187 187 *(ts.begin() + key) = value;
188 188 });
189 189
190 190 py::class_<MultiComponentTimeSerie::iterator_t>(m,
191 191 "MultiComponentTimeSerieItem")
192 192 .def("__getitem__", [](MultiComponentTimeSerie::iterator_t& self,
193 193 std::size_t key) { return (*self)[key]; })
194 194 .def("__setitem__",
195 195 [](MultiComponentTimeSerie::iterator_t& self, std::size_t key,
196 196 double value) { (*self)[key] = value; });
197 197
198 198 py::class_<MultiComponentTimeSerie, TimeSeries::ITimeSerie,
199 199 std::shared_ptr<MultiComponentTimeSerie>>(
200 200 m, "MultiComponentTimeSerie")
201 201 .def(py::init<>())
202 202 .def(py::init<const std::vector<std::size_t>>())
203 203 .def(py::init([](py::array_t<double> t, py::array_t<double> values) {
204 204 assert((t.size() < values.size()) |
205 205 (t.size() == 0)); // TODO check geometry
206 206 MultiComponentTimeSerie::axis_t _t(t.size());
207 207 MultiComponentTimeSerie::container_type<
208 208 MultiComponentTimeSerie::raw_value_type>
209 209 _values(values.size());
210 210 copy_multicomp(t, values, _t, _values);
211 211 std::vector<std::size_t> shape;
212 212 shape.push_back(values.shape(0));
213 213 shape.push_back(values.shape(1));
214 214 return MultiComponentTimeSerie(_t, _values, shape);
215 215 }))
216 216 .def("__getitem__",
217 217 [](MultiComponentTimeSerie& ts,
218 218 std::size_t key) -> MultiComponentTimeSerie::iterator_t {
219 219 return ts.begin() + key;
220 220 });
221 221
222 222 py::class_<SpectrogramTimeSerie::iterator_t>(m, "SpectrogramTimeSerieItem")
223 223 .def("__getitem__", [](SpectrogramTimeSerie::iterator_t& self,
224 224 std::size_t key) { return (*self)[key]; })
225 225 .def("__setitem__",
226 226 [](SpectrogramTimeSerie::iterator_t& self, std::size_t key,
227 227 double value) { (*self)[key] = value; });
228 228
229 229 py::class_<SpectrogramTimeSerie, TimeSeries::ITimeSerie,
230 230 std::shared_ptr<SpectrogramTimeSerie>>(m, "SpectrogramTimeSerie")
231 231 .def(py::init<>())
232 232 .def(py::init<const std::vector<std::size_t>>())
233 233 .def(py::init([](py::array_t<double> t, py::array_t<double> y,
234 234 py::array_t<double> values) {
235 assert(t.size() < values.size()); // TODO check geometry
235 auto t_s = t.size();
236 auto v_s = values.size();
237 assert(t.size() < values.size() or
238 t.size() == 0); // TODO check geometry
236 239 assert(y.size() == values.shape(1));
237 240 SpectrogramTimeSerie::axis_t _t(t.size());
238 241 SpectrogramTimeSerie::axis_t _y(y.size());
239 242 SpectrogramTimeSerie::container_type<
240 243 SpectrogramTimeSerie::raw_value_type>
241 244 _values(values.size());
242 245 copy_spectro(t, y, values, _t, _y, _values);
243 246 std::vector<std::size_t> shape;
244 247 shape.push_back(values.shape(0));
245 248 shape.push_back(values.shape(1));
246 return SpectrogramTimeSerie(_t, _y, _values, shape);
249 return SpectrogramTimeSerie(std::move(_t), std::move(_y),
250 std::move(_values), shape);
247 251 }))
248 252 .def("__getitem__",
249 253 [](SpectrogramTimeSerie& ts,
250 254 std::size_t key) -> SpectrogramTimeSerie::iterator_t {
251 255 return ts.begin() + key;
252 256 });
253 257
254 258 py::class_<Variable2, std::shared_ptr<Variable2>>(m, "Variable2")
255 259 .def(py::init<const QString&>())
256 260 .def_property("name", &Variable2::name, &Variable2::setName)
257 261 .def_property_readonly("range", &Variable2::range)
258 262 .def_property_readonly("nbPoints", &Variable2::nbPoints)
259 263 .def_property_readonly(
260 264 "data",
261 265 [](Variable2& var) -> std::shared_ptr<TimeSeries::ITimeSerie> {
262 266 return var.data();
263 267 })
264 268 .def("set_data",
265 269 [](Variable2& var, std::vector<TimeSeries::ITimeSerie*> ts_list,
266 270 const DateTimeRange& range) { var.setData(ts_list, range); })
267 271 .def("__len__", &Variable2::nbPoints)
268 272 .def("__repr__", __repr__<Variable2>);
269 273
270 274 py::class_<DateTimeRange>(m, "SqpRange")
271 275 //.def("fromDateTime", &DateTimeRange::fromDateTime,
272 276 // py::return_value_policy::move)
273 277 .def(py::init([](double start, double stop) {
274 278 return DateTimeRange{start, stop};
275 279 }))
276 280 .def(py::init(
277 281 [](system_clock::time_point start, system_clock::time_point stop) {
278 282 double start_ =
279 283 0.001 *
280 284 duration_cast<milliseconds>(start.time_since_epoch()).count();
281 285 double stop_ =
282 286 0.001 *
283 287 duration_cast<milliseconds>(stop.time_since_epoch()).count();
284 288 return DateTimeRange{start_, stop_};
285 289 }))
286 290 .def_property_readonly("start",
287 291 [](const DateTimeRange& range) {
288 292 return system_clock::from_time_t(range.m_TStart);
289 293 })
290 294 .def_property_readonly("stop",
291 295 [](const DateTimeRange& range) {
292 296 return system_clock::from_time_t(range.m_TEnd);
293 297 })
294 298 .def("__repr__", __repr__<DateTimeRange>);
295 299 }
General Comments 0
You need to be logged in to leave comments. Login now