HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r84:483146a07a5f

Mostly working Spectrograms...

jeandet -

r84:483146a07a5f

parent child

Context file:

r84:483146a07a5f

DebugHelpers/datetimerange.py +1 0

             #!/usr/bin/env python3
             from dumper import *
             import sys
             import os
             import numpy as np
             import datetime
             import time
             def qdump__DateTimeRange(d , value):
                 """
                 :param d: DumperBase
                 :param value: Value
                 """
                 tstart = datetime.datetime.utcfromtimestamp(value['m_TStart'].to('d'))
                 tstop = datetime.datetime.utcfromtimestamp(value['m_TEnd'].to('d'))
                 delta = str(tstop - tstart)
                 tstart, tstop = str(tstart), str(tstop)
                 d.putValue(tstart + ' : ' + tstop)
                 d.putNumChild(3)
                 if d.isExpanded():
                     with Children(d, 3):
                         with SubItem(d, "start"):
                             d.putValue(tstart)
                         with SubItem(d, "stop"):
                             d.putValue(tstop)
                         with SubItem(d, "delta"):
                             d.putValue(delta)

external/TimeSeries +1 -1

	@@ -1,1 +1,1
	1	Subproject commit f5f4debc597b41ab1849dfc02b6e092bf58c32d2		1	Subproject commit 22e3e4553178230053aac40131b4fdb36c163075

include/Common/cpp_utils.h +27 -19

@@ -1,29 +1,37
1	#ifndef CPP_UTILS_H	1	#ifndef CPP_UTILS_H
2	#define CPP_UTILS_H	2	#define CPP_UTILS_H
3		3
		4	#include <functional>
		5	#include <tuple>
4	#include <type_traits>	6	#include <type_traits>
5		7
6	template< class... >	8	template<class...> using void_t = void;
7	using void_t = void;
8		9
9	#define HAS_METHOD(method)\	10	#define HAS_METHOD(method) \
10	template <class T, class=void>\	11	template<class T, class = void> struct _has_##method : std::false_type \
11	struct _has_##method : std::false_type{};\	12	{}; \
12	\	13	\
13	template <class T>\	14	template<class T> \
14	struct _has_##method<T, void_t<std::is_member_function_pointer<decltype(&T::method)>>>\	15	struct _has_##method< \
15	: std::true_type{};\	16	T, void_t<std::is_member_function_pointer<decltype(&T::method)>>> \
16	\	17	: std::true_type \
17	template< class T>\	18	{}; \
18	static inline constexpr bool has_##method = _has_##method<T>::value;	19	\
		20	template<class T> \
		21	static inline constexpr bool has_##method = _has_##method<T>::value;
19		22
20	//taken from here https://www.fluentcpp.com/2017/10/27/function-aliases-cpp/	23	// taken from here https://www.fluentcpp.com/2017/10/27/function-aliases-cpp/
21	#define ALIAS_TEMPLATE_FUNCTION(highLevelF, lowLevelF) \	24	#define ALIAS_TEMPLATE_FUNCTION(highLevelF, lowLevelF) \
22	template <typename... Args> \	25	template<typename... Args> \
23	inline auto highLevelF(Args &&... args)->decltype(lowLevelF(std::forward<Args>(args)...)) \	26	inline auto highLevelF(Args&&... args) \
24	{ \	27	->decltype(lowLevelF(std::forward<Args>(args)...)) \
25	~~return lowLevelF(std::forward<Args>(args)...);~~ \	28	{ \
26	}	29	return lowLevelF(std::forward<Args>(args)...); \
		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	#endif // CPP_UTILS_H	37	#endif // CPP_UTILS_H

include/Data/SpectrogramTimeSerie.h +3 -3

             #ifndef SCIQLOP_SPECTROGRAMTIMESERIE_H
             #define SCIQLOP_SPECTROGRAMTIMESERIE_H
             #include "CoreGlobal.h"
             #include <TimeSeries.h>
             class SCIQLOP_CORE_EXPORT SpectrogramTimeSerie
                 : public TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>
             {
             public:
               using item_t =
                   decltype(std::declval<
                            TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>>()[0]);
               using iterator_t = decltype(
                   std::declval<TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>>()
                       .begin());
               SpectrogramTimeSerie() {}
-              SpectrogramTimeSerie(SpectrogramTimeSerie::axis_t& t,
+              SpectrogramTimeSerie(SpectrogramTimeSerie::axis_t&& t,
-                                   SpectrogramTimeSerie::axis_t& y,
+                                   SpectrogramTimeSerie::axis_t&& y,
                                    SpectrogramTimeSerie::container_type<
-                                       SpectrogramTimeSerie::raw_value_type>& values,
+                                       SpectrogramTimeSerie::raw_value_type>&& values,
                                    std::vector<std::size_t>& shape)
                   : TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>(t, values, shape)
               {
                 _axes[1] = y;
               }
               ~SpectrogramTimeSerie() = default;
               using TimeSerie::TimeSerie;
             };
             #endif // SCIQLOP_SPECTROGRAMTIMESERIE_H

include/Data/TimeSeriesUtils.h +42 0

             #ifndef TIMESERIESUTILS_H
             #define TIMESERIESUTILS_H
             #include "MultiComponentTimeSerie.h"
             #include "ScalarTimeSerie.h"
             #include "SpectrogramTimeSerie.h"
             #include "VectorTimeSerie.h"
             #include <TimeSeries.h>
+            #include <cmath>
             #include <memory>
             namespace TimeSeriesUtils
             {
               template<typename T> TimeSeries::ITimeSerie* copy(T input_ts)
               {
                 if constexpr(std::is_base_of_v<TimeSeries::ITimeSerie, T>)
                 {
                   if(auto ts = dynamic_cast<VectorTimeSerie*>(input_ts))
                   { return new VectorTimeSerie(*ts); }
                   if(auto ts = dynamic_cast<ScalarTimeSerie*>(input_ts))
                   { return new ScalarTimeSerie(*ts); }
                   if(auto ts = dynamic_cast<MultiComponentTimeSerie*>(input_ts))
                   { return new MultiComponentTimeSerie(*ts); }
                   if(auto ts = dynamic_cast<SpectrogramTimeSerie*>(input_ts))
                   { return new SpectrogramTimeSerie(*ts); }
                 }
                 else
                 {
                   if(auto ts = std::dynamic_pointer_cast<VectorTimeSerie>(input_ts))
                   { return new VectorTimeSerie(*ts); }
                   if(auto ts = std::dynamic_pointer_cast<ScalarTimeSerie>(input_ts))
                   { return new ScalarTimeSerie(*ts); }
                   if(auto ts = std::dynamic_pointer_cast<SpectrogramTimeSerie>(input_ts))
                   { return new SpectrogramTimeSerie(*ts); }
                   if(auto ts = std::dynamic_pointer_cast<MultiComponentTimeSerie>(input_ts))
                   { return new MultiComponentTimeSerie(*ts); }
                 }
                 return nullptr;
               }
+              struct axis_properties
+              {
+                double range;
+                double max_resolution;
+                bool is_log;
+              };
+              constexpr auto IsLog    = true;
+              constexpr auto IsLinear = false;
+              constexpr auto CheckMedian     = true;
+              constexpr auto DontCheckMedian = false;
+              template<bool is_log, bool check_median>
+              axis_properties axis_analysis(
+                  typename std::conditional<is_log, std::vector<double>&,
+                                            const std::vector<double>&>::type axis)
+              {
+                std::vector<double> axis_diff(axis.size());
+                if constexpr(is_log)
+                {
+                  std::transform(std::cbegin(axis), std::cend(axis), std::begin(axis),
+                                 [](const auto v) { return std::log10(v); });
+                }
+                auto range = *(std::cend(axis) - 1) - *(std::begin(axis));
+                std::adjacent_difference(std::cbegin(axis), std::cend(axis),
+                                         std::begin(axis_diff));
+                auto min_diff =
+                    (*std::min_element(std::cbegin(axis_diff) + 1, std::cend(axis_diff)));
+                if constexpr(check_median)
+                {
+                  std::nth_element(std::begin(axis_diff) + 1,
+                                   std::begin(axis_diff) + axis_diff.size() / 2,
+                                   std::end(axis_diff));
+                  auto median_diff = *(std::begin(axis_diff) + axis_diff.size() / 2);
+                  if(median_diff > (4 * min_diff)) min_diff = median_diff;
+                }
+                return {range, min_diff, is_log};
+              }
             } // namespace TimeSeriesUtils
             #endif

src/Variable/Variable2.cpp +10 0

             #include "Variable/Variable2.h"
             #define PROPERTY_(property, getter, setter, type)                              \
               type getter() noexcept                                                       \
               {                                                                            \
                 QReadLocker lock{&m_Lock};                                                 \
                 return property;                                                           \
               }                                                                            \
               void setter(const type& getter) noexcept                                     \
               {                                                                            \
                 QWriteLocker lock{&m_Lock};                                                \
                 property = getter;                                                         \
               }                                                                            \
               type property;
             #define V_FW_GETTER_SETTER(getter, setter, type)                               \
               type Variable2::getter()                                                     \
               {                                                                            \
                 QReadLocker lock{&this->m_lock};                                           \
                 return impl->getter();                                                     \
               }                                                                            \
               void Variable2::setter(const type& value)                                    \
               {                                                                            \
                 {                                                                          \
                   QWriteLocker lock{&this->m_lock};                                        \
                   impl->setter(value);                                                     \
                 }                                                                          \
                 emit updated(this->ID());                                                  \
               }
             static DataSeriesType findDataSeriesType(const QVariantHash& metadata)
             {
               auto dataSeriesType = DataSeriesType::NONE;
               // Go through the metadata and stop at the first value that could be converted
               // to DataSeriesType
               for(auto it = metadata.cbegin(), end = metadata.cend();
                   it != end && dataSeriesType == DataSeriesType::NONE; ++it)
               {
                 dataSeriesType = DataSeriesTypeUtils::fromString(it.value().toString());
               }
               return dataSeriesType;
             }
             std::shared_ptr<TimeSeries::ITimeSerie>
             clone_ts(const std::shared_ptr<TimeSeries::ITimeSerie>& ts)
             {
               if(auto scal_ts = std::dynamic_pointer_cast<ScalarTimeSerie>(ts))
                 return std::make_shared<ScalarTimeSerie>(*scal_ts);
               if(auto scal_ts = std::dynamic_pointer_cast<VectorTimeSerie>(ts))
                 return std::make_shared<VectorTimeSerie>(*scal_ts);
               if(auto scal_ts = std::dynamic_pointer_cast<SpectrogramTimeSerie>(ts))
                 return std::make_shared<SpectrogramTimeSerie>(*scal_ts);
               return nullptr;
             }
             struct Variable2::VariablePrivate
             {
               VariablePrivate(const QString& name, const QVariantHash& metadata)
                   : m_Name{name}, m_Range{INVALID_RANGE}, m_Metadata{metadata}, m_TimeSerie{
                                                                                     nullptr}
               {
                 switch(findDataSeriesType(metadata))
                 {
                   case DataSeriesType::SCALAR:
                     m_TimeSerie = std::make_shared<ScalarTimeSerie>(ScalarTimeSerie{});
                     break;
                   case DataSeriesType::VECTOR:
                     m_TimeSerie = std::make_shared<VectorTimeSerie>(VectorTimeSerie{});
                     break;
                   case DataSeriesType::SPECTROGRAM:
                     m_TimeSerie =
                         std::make_shared<SpectrogramTimeSerie>(SpectrogramTimeSerie{});
                     break;
                   case DataSeriesType::MULTICOMPONENT:
                   {
                     std::size_t count = metadata.value(QString("size"), 0).toInt();
                     m_TimeSerie       = std::make_shared<MultiComponentTimeSerie>(
                         MultiComponentTimeSerie{{0, count}});
                   }
                   break;
                   default: break;
                 }
               }
               VariablePrivate(const VariablePrivate& other)
                   : m_Name{other.m_Name}, m_Range{other.m_Range},
                     m_Metadata{other.m_Metadata}, m_RealRange{other.m_RealRange}
               {
                 m_TimeSerie = clone_ts(other.m_TimeSerie);
               }
               std::size_t nbPoints()
               {
                 if(m_TimeSerie) return m_TimeSerie->size();
                 return 0;
               }
               DataSeriesType type() const
               {
                 return DataSeriesTypeUtils::type(m_TimeSerie.get());
               }
               PROPERTY_(m_Name, name, setName, QString)
               PROPERTY_(m_Range, range, setRange, DateTimeRange)
               PROPERTY_(m_Metadata, metadata, setMetadata, QVariantHash)
               PROPERTY_(m_RealRange, realRange, setRealRange, std::optional<DateTimeRange>)
               std::shared_ptr<TimeSeries::ITimeSerie> dataSeries() { return m_TimeSerie; }
               void setDataSeries(std::shared_ptr<TimeSeries::ITimeSerie>&& timeSerie)
               {
                 QWriteLocker lock{&m_Lock};
                 m_TimeSerie = timeSerie;
                 if(m_TimeSerie) { setRealRange(DateTimeRange(m_TimeSerie->axis_range(0))); }
                 else
                 {
                   setRealRange(std::nullopt);
                 }
               }
               std::shared_ptr<TimeSeries::ITimeSerie> m_TimeSerie;
               QReadWriteLock m_Lock{QReadWriteLock::Recursive};
             };
             Variable2::Variable2(const QString& name, const QVariantHash& metadata)
                 : impl{spimpl::make_unique_impl<VariablePrivate>(name, metadata)},
                   _uuid{QUuid::createUuid()}
             {}
             Variable2::Variable2(const Variable2& other)
                 : impl{spimpl::make_unique_impl<VariablePrivate>(*other.impl)},
                   _uuid{QUuid::createUuid()} // is a clone but must have a != uuid
             {}
             std::shared_ptr<Variable2> Variable2::clone() const
             {
               return std::make_shared<Variable2>(*this);
             }
             V_FW_GETTER_SETTER(name, setName, QString)
             DateTimeRange Variable2::range() { return impl->range(); }
             void Variable2::setRange(const DateTimeRange& range)
             {
               QWriteLocker lock{&m_lock};
               impl->setRange(range);
             }
             std::optional<DateTimeRange> Variable2::realRange()
             {
               QReadLocker lock{&m_lock};
               return impl->realRange();
             }
             std::size_t Variable2::nbPoints() { return impl->nbPoints(); }
             std::shared_ptr<TimeSeries::ITimeSerie> Variable2::data()
             {
               return impl->dataSeries();
             }
             DataSeriesType Variable2::type()
             {
               QReadLocker lock{&m_lock};
               return impl->type();
             }
             QVariantHash Variable2::metadata() const noexcept { return impl->metadata(); }
             template<typename T>
             std::shared_ptr<TimeSeries::ITimeSerie>
             _merge(std::vector<TimeSeries::ITimeSerie*> source, const DateTimeRange& range)
             {
               std::sort(std::begin(source), std::end(source),
                         [](TimeSeries::ITimeSerie* a, TimeSeries::ITimeSerie* b) {
                           if(a->size() && b->size()) return a->t(0) < b->t(0);
                           return false;
                         });
               std::shared_ptr<TimeSeries::ITimeSerie> dest = std::make_shared<T>();
               std::for_each(
                   std::begin(source), std::end(source),
                   [&dest, &range](TimeSeries::ITimeSerie* serie) {
                     auto& ts    = *static_cast<T*>(serie);
                     auto last_t = range.m_TStart;
                     if(dest->size()) last_t = dest->axis(0).back();
                     if(ts.size())
                     {
                       std::copy(std::upper_bound(
                                     std::begin(ts), std::end(ts), last_t,
                                     [](const auto& a, const auto& b) { return a < b.t(); }),
                                 std::lower_bound(
                                     std::begin(ts), std::end(ts), range.m_TEnd,
                                     [](const auto& a, const auto& b) { return a.t() < b; }),
                                 std::back_inserter(*std::dynamic_pointer_cast<T>(dest)));
                     }
                   });
+              if(source.size())
+              {
+                const auto& first = *source.begin();
+                for(std::size_t ax_index = 1; ax_index < first->shape().size(); ax_index++)
+                {
+                  const auto& ax = first->axis(ax_index);
+                  std::copy(std::cbegin(ax), std::cend(ax),
+                            std::back_inserter(dest->axis(ax_index)));
+                }
+              }
               return dest;
             }
             std::shared_ptr<TimeSeries::ITimeSerie>
             merge(const std::vector<TimeSeries::ITimeSerie*>& dataSeries,
                   const DateTimeRange& range)
             {
               if(dynamic_cast<ScalarTimeSerie*>(dataSeries.front()))
                 return _merge<ScalarTimeSerie>(dataSeries, range);
               if(dynamic_cast<VectorTimeSerie*>(dataSeries.front()))
                 return _merge<VectorTimeSerie>(dataSeries, range);
               if(dynamic_cast<MultiComponentTimeSerie*>(dataSeries.front()))
                 return _merge<MultiComponentTimeSerie>(dataSeries, range);
               if(dynamic_cast<SpectrogramTimeSerie*>(dataSeries.front()))
                 return _merge<SpectrogramTimeSerie>(dataSeries, range);
               return std::shared_ptr<TimeSeries::ITimeSerie>{};
             }
             void Variable2::setData(const std::vector<TimeSeries::ITimeSerie*>& dataSeries,
                                     const DateTimeRange& range, bool notify)
             {
               if(dataSeries.size())
               {
                 {
                   QWriteLocker lock{&m_lock};
                   impl->setDataSeries(merge(dataSeries, range));
                   impl->setRange(range);
                 }
                 if(notify) emit this->updated(this->ID());
               }
             }

src/pybind11_wrappers/CoreWrappers.cpp +6 -2

             #include "CoreWrappers.h"
             #include "pywrappers_common.h"
             #include <Data/DataSeriesType.h>
             #include <Data/IDataProvider.h>
             #include <Network/Downloader.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable2.h>
             #include <Variable/VariableController2.h>
             #include <pybind11/chrono.h>
             #include <pybind11/embed.h>
             #include <pybind11/functional.h>
             #include <pybind11/numpy.h>
             #include <pybind11/operators.h>
             #include <pybind11/pybind11.h>
             #include <pybind11/stl.h>
             #include <pybind11/stl_bind.h>
             #include <sstream>
             #include <string>
             namespace py = pybind11;
             using namespace std::chrono;
             template<typename T, typename U, bool row_major = true>
             void copy_vector(py::array_t<double>& t, py::array_t<double>& values, T& dest_t,
                              U& dest_values)
             {
               auto t_view      = t.unchecked<1>();
               auto values_view = values.unchecked<2>();
               for(std::size_t i = 0; i < t.size(); i++)
               {
                 dest_t[i]      = t_view[i];
                 dest_values[i] = {values_view(i, 0), values_view(i, 1), values_view(i, 2)};
               }
             }
             template<typename T, typename U>
             void copy_scalar(py::array_t<double>& t, py::array_t<double>& values, T& dest_t,
                              U& dest_values)
             {
               auto t_view = t.unchecked<1>();
               if(values.ndim() == 1)
               {
                 auto values_view = values.unchecked<1>();
                 for(std::size_t i = 0; i < t.size(); i++)
                 {
                   dest_t[i]      = t_view[i];
                   dest_values[i] = values_view[i];
                 }
               }
               else if(values.ndim() == 2 && values.shape(1) == 1)
               {
                 auto values_view = values.unchecked<2>();
                 for(std::size_t i = 0; i < t.size(); i++)
                 {
                   dest_t[i]      = t_view[i];
                   dest_values[i] = values_view(i, 0);
                 }
               }
             }
             template<typename T, typename U>
             void copy_multicomp(py::array_t<double>& t, py::array_t<double>& values,
                                 T& dest_t, U& dest_values)
             {
               auto t_view      = t.unchecked<1>();
               auto values_view = values.unchecked<2>();
               const auto width = values.shape(1);
               for(std::size_t i = 0; i < t.size(); i++)
               {
                 dest_t[i] = t_view[i];
                 for(int j = 0; j < width; j++)
                 {
                   dest_values[i * width + j] = values_view(i, j);
                 }
               }
             }
             template<typename T, typename U>
             void copy_spectro(py::array_t<double>& t, py::array_t<double>& y,
                               py::array_t<double>& values, T& dest_t, T& dest_y,
                               U& dest_values)
             {
               auto t_view      = t.unchecked<1>();
               auto y_view      = y.unchecked<1>();
               auto values_view = values.unchecked<2>();
               const auto width = values.shape(1);
               for(std::size_t i = 0; i < y.size(); i++)
               {
                 dest_y[i] = y_view[i];
               }
               for(std::size_t i = 0; i < t.size(); i++)
               {
                 dest_t[i] = t_view[i];
                 for(int j = 0; j < width; j++)
                 {
                   dest_values[i * width + j] = values_view(i, j);
                 }
               }
             }
             PYBIND11_MODULE(pysciqlopcore, m)
             {
               pybind11::bind_vector<std::vector<double>>(m, "VectorDouble");
               py::enum_<DataSeriesType>(m, "DataSeriesType")
                   .value("SCALAR", DataSeriesType::SCALAR)
                   .value("SPECTROGRAM", DataSeriesType::SPECTROGRAM)
                   .value("VECTOR", DataSeriesType::VECTOR)
                   .value("MULTICOMPONENT", DataSeriesType::MULTICOMPONENT)
                   .value("NONE", DataSeriesType::NONE)
                   .export_values();
               py::class_<Response>(m, "Response")
                   .def("status_code", &Response::status_code);
               py::class_<Downloader>(m, "Downloader")
                   .def_static("get", Downloader::get)
                   .def_static("getAsync", Downloader::getAsync)
                   .def_static("downloadFinished", Downloader::downloadFinished);
               py::class_<IDataProvider, std::shared_ptr<IDataProvider>>(m, "IDataProvider");
               py::class_<TimeSeries::ITimeSerie, std::shared_ptr<TimeSeries::ITimeSerie>>(
                   m, "ITimeSerie")
                   .def_property_readonly(
                       "size", [](const TimeSeries::ITimeSerie& ts) { return ts.size(); })
                   .def("__len__",
                        [](const TimeSeries::ITimeSerie& ts) { return ts.size(); })
                   .def_property_readonly(
                       "shape", [](const TimeSeries::ITimeSerie& ts) { return ts.shape(); })
                   .def_property_readonly(
                       "t",
                       [](TimeSeries::ITimeSerie& ts) -> decltype(ts.axis(0))& {
                         return ts.axis(0);
                       },
                       py::return_value_policy::reference)
                   .def(
                       "axis",
                       [](TimeSeries::ITimeSerie& ts, unsigned int index)
                           -> decltype(ts.axis(0))& { return ts.axis(index); },
                       py::return_value_policy::reference);
               py::class_<ScalarTimeSerie, TimeSeries::ITimeSerie,
                          std::shared_ptr<ScalarTimeSerie>>(m, "ScalarTimeSerie")
                   .def(py::init<>())
                   .def(py::init<std::size_t>())
                   .def(py::init([](py::array_t<double> t, py::array_t<double> values) {
                     assert(t.size() == values.size());
                     ScalarTimeSerie::axis_t _t(t.size());
                     ScalarTimeSerie::axis_t _values(t.size());
                     copy_scalar(t, values, _t, _values);
                     return ScalarTimeSerie(_t, _values);
                   }))
                   .def("__getitem__",
                        [](ScalarTimeSerie& ts, std::size_t key) { return ts[key]; })
                   .def("__setitem__", [](ScalarTimeSerie& ts, std::size_t key,
                                          double value) { *(ts.begin() + key) = value; });
               py::class_<VectorTimeSerie::raw_value_type>(m, "vector")
                   .def(py::init<>())
                   .def(py::init<double, double, double>())
                   .def("__repr__", __repr__<VectorTimeSerie::raw_value_type>)
                   .def_readwrite("x", &VectorTimeSerie::raw_value_type::x)
                   .def_readwrite("y", &VectorTimeSerie::raw_value_type::y)
                   .def_readwrite("z", &VectorTimeSerie::raw_value_type::z);
               py::class_<VectorTimeSerie, TimeSeries::ITimeSerie,
                          std::shared_ptr<VectorTimeSerie>>(m, "VectorTimeSerie")
                   .def(py::init<>())
                   .def(py::init<std::size_t>())
                   .def(py::init([](py::array_t<double> t, py::array_t<double> values) {
                     assert(t.size() * 3 == values.size());
                     VectorTimeSerie::axis_t _t(t.size());
                     VectorTimeSerie::container_type<VectorTimeSerie::raw_value_type>
                         _values(t.size());
                     copy_vector(t, values, _t, _values);
                     return VectorTimeSerie(_t, _values);
                   }))
                   .def(
                       "__getitem__",
                       [](VectorTimeSerie& ts, std::size_t key)
                           -> VectorTimeSerie::raw_value_type& { return ts[key]; },
                       py::return_value_policy::reference)
                   .def("__setitem__", [](VectorTimeSerie& ts, std::size_t key,
                                          VectorTimeSerie::raw_value_type value) {
                     *(ts.begin() + key) = value;
                   });
               py::class_<MultiComponentTimeSerie::iterator_t>(m,
                                                               "MultiComponentTimeSerieItem")
                   .def("__getitem__", [](MultiComponentTimeSerie::iterator_t& self,
                                          std::size_t key) { return (*self)[key]; })
                   .def("__setitem__",
                        [](MultiComponentTimeSerie::iterator_t& self, std::size_t key,
                           double value) { (*self)[key] = value; });
               py::class_<MultiComponentTimeSerie, TimeSeries::ITimeSerie,
                          std::shared_ptr<MultiComponentTimeSerie>>(
                   m, "MultiComponentTimeSerie")
                   .def(py::init<>())
                   .def(py::init<const std::vector<std::size_t>>())
                   .def(py::init([](py::array_t<double> t, py::array_t<double> values) {
                     assert((t.size() < values.size()) |
                            (t.size() == 0)); // TODO check geometry
                     MultiComponentTimeSerie::axis_t _t(t.size());
                     MultiComponentTimeSerie::container_type<
                         MultiComponentTimeSerie::raw_value_type>
                         _values(values.size());
                     copy_multicomp(t, values, _t, _values);
                     std::vector<std::size_t> shape;
                     shape.push_back(values.shape(0));
                     shape.push_back(values.shape(1));
                     return MultiComponentTimeSerie(_t, _values, shape);
                   }))
                   .def("__getitem__",
                        [](MultiComponentTimeSerie& ts,
                           std::size_t key) -> MultiComponentTimeSerie::iterator_t {
                          return ts.begin() + key;
                        });
               py::class_<SpectrogramTimeSerie::iterator_t>(m, "SpectrogramTimeSerieItem")
                   .def("__getitem__", [](SpectrogramTimeSerie::iterator_t& self,
                                          std::size_t key) { return (*self)[key]; })
                   .def("__setitem__",
                        [](SpectrogramTimeSerie::iterator_t& self, std::size_t key,
                           double value) { (*self)[key] = value; });
               py::class_<SpectrogramTimeSerie, TimeSeries::ITimeSerie,
                          std::shared_ptr<SpectrogramTimeSerie>>(m, "SpectrogramTimeSerie")
                   .def(py::init<>())
                   .def(py::init<const std::vector<std::size_t>>())
                   .def(py::init([](py::array_t<double> t, py::array_t<double> y,
                                    py::array_t<double> values) {
-                    assert(t.size() < values.size()); // TODO check geometry
+                    auto t_s = t.size();
+                    auto v_s = values.size();
+                    assert(t.size() < values.size() or
+                           t.size() == 0); // TODO check geometry
                     assert(y.size() == values.shape(1));
                     SpectrogramTimeSerie::axis_t _t(t.size());
                     SpectrogramTimeSerie::axis_t _y(y.size());
                     SpectrogramTimeSerie::container_type<
                         SpectrogramTimeSerie::raw_value_type>
                         _values(values.size());
                     copy_spectro(t, y, values, _t, _y, _values);
                     std::vector<std::size_t> shape;
                     shape.push_back(values.shape(0));
                     shape.push_back(values.shape(1));
-                    return SpectrogramTimeSerie(_t, _y, _values, shape);
+                    return SpectrogramTimeSerie(std::move(_t), std::move(_y),
+                                                std::move(_values), shape);
                   }))
                   .def("__getitem__",
                        [](SpectrogramTimeSerie& ts,
                           std::size_t key) -> SpectrogramTimeSerie::iterator_t {
                          return ts.begin() + key;
                        });
               py::class_<Variable2, std::shared_ptr<Variable2>>(m, "Variable2")
                   .def(py::init<const QString&>())
                   .def_property("name", &Variable2::name, &Variable2::setName)
                   .def_property_readonly("range", &Variable2::range)
                   .def_property_readonly("nbPoints", &Variable2::nbPoints)
                   .def_property_readonly(
                       "data",
                       [](Variable2& var) -> std::shared_ptr<TimeSeries::ITimeSerie> {
                         return var.data();
                       })
                   .def("set_data",
                        [](Variable2& var, std::vector<TimeSeries::ITimeSerie*> ts_list,
                           const DateTimeRange& range) { var.setData(ts_list, range); })
                   .def("__len__", &Variable2::nbPoints)
                   .def("__repr__", __repr__<Variable2>);
               py::class_<DateTimeRange>(m, "SqpRange")
                   //.def("fromDateTime", &DateTimeRange::fromDateTime,
                   // py::return_value_policy::move)
                   .def(py::init([](double start, double stop) {
                     return DateTimeRange{start, stop};
                   }))
                   .def(py::init(
                       [](system_clock::time_point start, system_clock::time_point stop) {
                         double start_ =
 .001 *
                             duration_cast<milliseconds>(start.time_since_epoch()).count();
                         double stop_ =
 .001 *
                             duration_cast<milliseconds>(stop.time_since_epoch()).count();
                         return DateTimeRange{start_, stop_};
                       }))
                   .def_property_readonly("start",
                                          [](const DateTimeRange& range) {
                                            return system_clock::from_time_t(range.m_TStart);
                                          })
                   .def_property_readonly("stop",
                                          [](const DateTimeRange& range) {
                                            return system_clock::from_time_t(range.m_TEnd);
                                          })
                   .def("__repr__", __repr__<DateTimeRange>);
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages