HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r83:698d7cfa01b0

Some work on SpectrogramTS Python wrapper...

jeandet -

r83:698d7cfa01b0

parent child

Context file:

r83:698d7cfa01b0

include/Data/SpectrogramTimeSerie.h +10 0

             #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::axis_t& y,
+                                   SpectrogramTimeSerie::container_type<
+                                       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

src/pybind11_wrappers/CoreWrappers.cpp +41 -10

             #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>& values,
+            void copy_spectro(py::array_t<double>& t, py::array_t<double>& y,
-                              T& dest_t, U& dest_values)
+                              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__",
+                  .def(
-                       [](VectorTimeSerie& ts, std::size_t key)
+                      "__getitem__",
-                           -> VectorTimeSerie::raw_value_type& { return ts[key]; },
+                      [](VectorTimeSerie& ts, std::size_t key)
-                       py::return_value_policy::reference)
+                          -> 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_spectro(t, values, _t, _values);
+                    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> values) {
+                  .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
+                    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, values, _t, _values);
+                    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, _values, shape);
+                    return SpectrogramTimeSerie(_t, _y, _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>);
             }

tests/TestVariables.py +8 -6

             import sys
             import os
             if not hasattr(sys, 'argv') or len(sys.argv)==0:
                 sys.argv = ['']
             current_script_path = os.path.dirname(os.path.realpath(__file__))
             sys.path.append(current_script_path)
             import sciqlopqt
             import pysciqlopcore
             import numpy as np
             import pandas as pds
             import datetime
             import time
             import unittest
             import ddt
             def listify(obj):
                 if hasattr(obj, "__getitem__"):
                     return obj
                 return [obj]
             @ddt.ddt
             class TimeSeriesCtors(unittest.TestCase):
                 @ddt.data(
                          (pysciqlopcore.ScalarTimeSerie,10),
                          (pysciqlopcore.VectorTimeSerie,10),
                          (pysciqlopcore.SpectrogramTimeSerie,[10,10]),
                          (pysciqlopcore.MultiComponentTimeSerie,[10,10]),
                          (pysciqlopcore.ScalarTimeSerie,0),
                          (pysciqlopcore.VectorTimeSerie,0),
                          (pysciqlopcore.SpectrogramTimeSerie,[0,10]),
                          (pysciqlopcore.MultiComponentTimeSerie,[0,10])
                 )
                 def test_construct(self, case):
                     ts = case[0](case[1])
                     self.assertEqual(ts.shape,listify(case[1]))
             class TimeSeriesData(unittest.TestCase):
                 def test_set_ScalarTimeSerie_values(self):
                     ts = pysciqlopcore.ScalarTimeSerie(10)
                     ts.t[0]=111.
                     self.assertEqual(ts.t[0],111.)
                     ts[0]=123.
                     self.assertEqual(ts[0],123.)
                 def test_set_VectorTimeSerie_values(self):
                     ts = pysciqlopcore.VectorTimeSerie(10)
                     ts.t[0]=111.
                     self.assertEqual(ts.t[0],111.)
                     ts[0].x=111.
                     ts[0].y=222.
                     ts[0].z=333.
                     self.assertEqual(ts[0].x,111.)
                     self.assertEqual(ts[0].y,222.)
                     self.assertEqual(ts[0].z,333.)
                 def test_set_SpectrogramTimeSerie_values(self):
                     ts = pysciqlopcore.SpectrogramTimeSerie((10,100))
                     ts.t[0]=111.
                     self.assertEqual(ts.t[0],111.)
                     ts[0][11]=123.
                     self.assertEqual(ts[0][11],123.)
                 def test_build_ScalarTimeSerie_from_np_arrays(self):
                     ts = pysciqlopcore.ScalarTimeSerie(np.arange(10), np.arange(10)*10)
                     for i in range(len(ts)):
                         self.assertEqual(ts[i],i*10.)
                 def test_build_VectorTimeSerie_from_np_arrays(self):
                     v=np.ones((10,3))
                     for i in range(3):
                         v.transpose()[:][i] = np.arange(10)*10**i
                     ts = pysciqlopcore.VectorTimeSerie(np.arange(10), v)
                     for i in range(len(ts)):
                         self.assertEqual(ts[i].x,i)
                         self.assertEqual(ts[i].y,i*10.)
                         self.assertEqual(ts[i].z,i*100.)
                 def test_build_MultiComponentTimeSerie_from_np_arrays(self):
                     v=np.ones((10,5))
                     for i in range(5):
                         v.transpose()[:][i] = np.arange(10)*10**i
                     ts = pysciqlopcore.MultiComponentTimeSerie(np.arange(10), v)
                     for i in range(len(ts)):
                         self.assertEqual(ts[i][0],i)
                         self.assertEqual(ts[i][1],i*10.)
                         self.assertEqual(ts[i][2],i*100.)
                 def test_build_MultiComponentTimeSerie_from_np_arrays_of_nan(self):
                     v=np.empty((2,5))
                     v.fill(np.nan)
                     ts = pysciqlopcore.MultiComponentTimeSerie(np.arange(2), v)
                     for i in range(len(ts)):
                         self.assertTrue(np.isnan(ts[i][0]))
                         self.assertTrue(np.isnan(ts[i][1]))
                         self.assertTrue(np.isnan(ts[i][2]))
                         self.assertTrue(np.isnan(ts[i][3]))
                 def test_build_VectorTimeSerie_from_np_arrays_row(self):
                     v=np.ones((10,3))
                     for i in range(3):
                         v.transpose()[:][i] = np.arange(10)*10**i
                     ts = pysciqlopcore.VectorTimeSerie(np.arange(10), v)
                     for i in range(len(ts)):
                         self.assertEqual(ts[i].x,i)
                         self.assertEqual(ts[i].y,i*10.)
                         self.assertEqual(ts[i].z,i*100.)
                 def test_build_ScalarTimeSerie_from_np_dataframe(self):
                     df = pds.DataFrame(data=np.zeros((10,1)),index=np.arange(10))
                     df[0] = np.arange(10)
                     ts = pysciqlopcore.ScalarTimeSerie(df.index.values, df.values)
                     for i in range(len(ts)):
                         self.assertEqual(ts[i],i)
                 def test_build_VectorTimeSerie_from_np_dataframe(self):
                     df = pds.DataFrame(data=np.zeros((10,3)),index=np.arange(10))
                     for i in range(3):
                         df[i] = np.arange(10)*10**i
                     ts = pysciqlopcore.VectorTimeSerie(df.index.values, df.values)
                     for i in range(len(ts)):
                         self.assertEqual(ts[i].x,i)
                         self.assertEqual(ts[i].y,i*10.)
                         self.assertEqual(ts[i].z,i*100.)
                 def test_build_SpectrogramTimeSerie_from_np_arrays(self):
-                    v=np.ones((10,4))
+                    v=np.ones((10,30))
-                    for i in range(4):
+                    for i in range(30):
-                        v.transpose()[:][i] = np.arange(10)*10**i
+                        v.transpose()[:][i] = np.arange(10)*10**(i/10.)
-                    ts = pysciqlopcore.SpectrogramTimeSerie(np.arange(10), v)
+                    ts = pysciqlopcore.SpectrogramTimeSerie(np.arange(10),np.arange(30), v)
                     for i in range(len(ts)):
-                        for j in range(4):
+                        for j in range(30):
-                            self.assertEqual(ts[i][j], i*10**j)
+                            self.assertEqual(ts[i][j], i*10**(j/10.))
+                    for i in range(30):
+                        self.assertEqual(ts.axis(1)[i], i)
             class VariableData(unittest.TestCase):
                 def test_default_state(self):
                     v=pysciqlopcore.Variable2("hello")
                     self.assertEqual(str(v.name), str("hello"))
                     self.assertEqual(type(v.data), type(None))
                     self.assertEqual(len(v), 0)
                 def test_set_name(self):
                     v=pysciqlopcore.Variable2("hello")
                     self.assertEqual(str(v.name), str("hello"))
                     v.name="newName"
                     self.assertEqual(str(v.name), str("newName"))
             if __name__ == '__main__':
                 unittest.main(exit=False)

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