HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r85:1e3f92d40b0e

Updated to fixed TS lib, added spectrogram min/max sampling hints when available...

jeandet -

r85:1e3f92d40b0e

parent child

Context file:

r85:1e3f92d40b0e

external/TimeSeries +1 -1

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

include/Data/SpectrogramTimeSerie.h +8 -2

              #include "CoreGlobal.h"
              #include <TimeSeries.h>
+             #include <cmath>
              class SCIQLOP_CORE_EXPORT SpectrogramTimeSerie
                  : public TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>
              {
              public:
+               double min_sampling = std::nan("");
+               double max_sampling = std::nan("");
                using item_t =
                    decltype(std::declval<
                             TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>>()[0]);
                                     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)
+                                    std::vector<std::size_t>& shape, double min_sampling,
+                                    double max_sampling)
+                   : TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>(t, values,
+                                                                            shape),
+                     min_sampling{min_sampling}, max_sampling{max_sampling}
                {
                  _axes[1] = y;
                }

include/Data/TimeSeriesUtils.h +23 -13

                  double range;
                  double max_resolution;
                  bool is_log;
+                 double min;
+                 double max;
                };
                constexpr auto IsLog    = true;
                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)
+                                             const std::vector<double>&>::type axis,
+                   double given_max_resolution = std::nan(""))
                {
                  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)
+                 auto min      = *std::begin(axis);
+                 auto max      = *(std::cend(axis) - 1);
+                 auto range    = max - min;
+                 auto min_diff = given_max_resolution;
+                 if(std::isnan(min_diff))
                  {
-                   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;
+                   std::adjacent_difference(std::cbegin(axis), std::cend(axis),
+                                            std::begin(axis_diff));
+                   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};
+                 return {range, min_diff, is_log, min, max};
                }
              } // namespace TimeSeriesUtils

include/Variable/private/VCTransaction.h +1 -1

                  {
                    auto ds = _provider->getData(
                        DataProviderParameters{{range}, _variable->metadata()});
-                   if(ds) data.push_back(ds);
+                   if(ds and ds->size()) data.push_back(ds); // skip empty dataSeries
                  }
                  if(_overwrite)
                    _variable->setData(data, _range, true);

src/Variable/Variable2.cpp +12 0

                              std::back_inserter(dest->axis(ax_index)));
                  }
                }
+               if constexpr(std::is_same_v<T, SpectrogramTimeSerie>)
+               {
+                 auto d = std::dynamic_pointer_cast<SpectrogramTimeSerie>(dest);
+                 if(std::isnan(d->max_sampling))
+                 {
+                   std::for_each(std::begin(source), std::end(source), [&d](auto src) {
+                     auto s = dynamic_cast<SpectrogramTimeSerie*>(src);
+                     if(!std::isnan(s->max_sampling)) { d->max_sampling = s->max_sampling; }
+                     if(!std::isnan(s->min_sampling)) { d->min_sampling = s->min_sampling; }
+                   });
+                 }
+               }
                return dest;
              }

src/Variable/VariableController2.cpp +1 0

                  }
                  data.push_back(var->data().get()); // might be smarter
                  var->setData(data, r, true);
+                 std::for_each(std::begin(data), std::end(data), [](auto ts) { delete ts; });
                }
              public:

src/pybind11_wrappers/CoreWrappers.cpp +10 -7

              #include "pywrappers_common.h"
+             #include <Common/debug.h>
              #include <Data/DataSeriesType.h>
              #include <Data/IDataProvider.h>
              #include <Network/Downloader.h>
                    .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) {
-                     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));
+                                    py::array_t<double> values, double min_sampling,
+                                    double max_sampling) {
+                     if(t.size() >= values.size() and t.size() != 0)
+                       SCIQLOP_ERROR(decltype(py::self), "Doesn't look like a Spectrogram");
+                     if(y.size() != values.shape(1))
+                       SCIQLOP_ERROR(decltype(py::self),
+                                     "Y axis size and data shape are incompatible");
                      SpectrogramTimeSerie::axis_t _t(t.size());
                      SpectrogramTimeSerie::axis_t _y(y.size());
                      SpectrogramTimeSerie::container_type<
                      shape.push_back(values.shape(0));
                      shape.push_back(values.shape(1));
                      return SpectrogramTimeSerie(std::move(_t), std::move(_y),
-                                                 std::move(_values), shape);
+                                                 std::move(_values), shape, min_sampling,
+                                                 max_sampling);
                    }))
                    .def("__getitem__",
                         [](SpectrogramTimeSerie& ts,

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