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)
+                                   std::vector<std::size_t>& shape, double min_sampling,
-                  : TimeSeries::TimeSerie<double, SpectrogramTimeSerie, 2>(t, values, shape)
+                                   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));
+                auto min      = *std::begin(axis);
-                std::adjacent_difference(std::cbegin(axis), std::cend(axis),
+                auto max      = *(std::cend(axis) - 1);
-                                         std::begin(axis_diff));
+                auto range    = max - min;
-                auto min_diff =
+                auto min_diff = given_max_resolution;
-                    (*std::min_element(std::cbegin(axis_diff) + 1, std::cend(axis_diff)));
+                if(std::isnan(min_diff))
-                if constexpr(check_median)
                 {
-                  std::nth_element(std::begin(axis_diff) + 1,
+                  std::adjacent_difference(std::cbegin(axis), std::cend(axis),
-                                   std::begin(axis_diff) + axis_diff.size() / 2,
+                                           std::begin(axis_diff));
-                                   std::end(axis_diff));
+                  min_diff =
-                  auto median_diff = *(std::begin(axis_diff) + axis_diff.size() / 2);
+                      (*std::min_element(std::cbegin(axis_diff) + 1, std::cend(axis_diff)));
-                  if(median_diff > (4 * min_diff)) min_diff = median_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

@@ -203,6 +203,18 _merge(std::vector<TimeSeries::ITimeSerie*> source, const DateTimeRange& range)
203	std::back_inserter(dest->axis(ax_index)));	203	std::back_inserter(dest->axis(ax_index)));
204	}	204	}
205	}	205	}
		206	if constexpr(std::is_same_v<T, SpectrogramTimeSerie>)
		207	{
		208	auto d = std::dynamic_pointer_cast<SpectrogramTimeSerie>(dest);
		209	if(std::isnan(d->max_sampling))
		210	{
		211	std::for_each(std::begin(source), std::end(source), [&d](auto src) {
		212	auto s = dynamic_cast<SpectrogramTimeSerie*>(src);
		213	if(!std::isnan(s->max_sampling)) { d->max_sampling = s->max_sampling; }
		214	if(!std::isnan(s->min_sampling)) { d->min_sampling = s->min_sampling; }
		215	});
		216	}
		217	}
206	return dest;	218	return dest;
207	}	219	}
208		220

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) {
+                                   py::array_t<double> values, double min_sampling,
-                    auto t_s = t.size();
+                                   double max_sampling) {
-                    auto v_s = values.size();
+                    if(t.size() >= values.size() and t.size() != 0)
-                    assert(t.size() < values.size() or
+                      SCIQLOP_ERROR(decltype(py::self), "Doesn't look like a Spectrogram");
-                           t.size() == 0); // TODO check geometry
+                    if(y.size() != values.shape(1))
-                    assert(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