HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/SciQLOPCore Commit - r43:54e194b00c35

Restored Spectrograms plots...

jeandet -

r43:54e194b00c35

parent child

Context file:

r43:54e194b00c35

include/Data/DataSeries.h +2 -2

             #ifndef SCIQLOP_DATASERIES_H
             #define SCIQLOP_DATASERIES_H
             #include "CoreGlobal.h"
             #include <Common/SortUtils.h>
             #include <Data/ArrayData.h>
             #include <Data/DataSeriesMergeHelper.h>
             #include <Data/IDataSeries.h>
             #include <Data/OptionalAxis.h>
             #include <QLoggingCategory>
             #include <QReadLocker>
             #include <QReadWriteLock>
             #include <memory>
             // We don't use the Qt macro since the log is used in the header file, which causes multiple log
             // definitions with inheritance. Inline method is used instead
             inline const QLoggingCategory &LOG_DataSeries()
             {
                 static const QLoggingCategory category{"DataSeries"};
                 return category;
             }
             template <int Dim>
             class DataSeries;
             namespace dataseries_detail {
             template <int Dim, bool IsConst>
             class IteratorValue : public DataSeriesIteratorValue::Impl {
             public:
                 friend class DataSeries<Dim>;
                 template <bool IC = IsConst, typename = std::enable_if_t<IC == false> >
                 explicit IteratorValue(DataSeries<Dim> &dataSeries, bool begin)
                         : m_XIt(begin ? dataSeries.xAxisData()->begin() : dataSeries.xAxisData()->end()),
                           m_ValuesIt(begin ? dataSeries.valuesData()->begin() : dataSeries.valuesData()->end()),
                           m_YItBegin{dataSeries.yAxis().begin()},
                           m_YItEnd{dataSeries.yAxis().end()}
                 {
                 }
                 template <bool IC = IsConst, typename = std::enable_if_t<IC == true> >
                 explicit IteratorValue(const DataSeries<Dim> &dataSeries, bool begin)
                         : m_XIt(begin ? dataSeries.xAxisData()->cbegin() : dataSeries.xAxisData()->cend()),
                           m_ValuesIt(begin ? dataSeries.valuesData()->cbegin()
                                            : dataSeries.valuesData()->cend()),
                           m_YItBegin{dataSeries.yAxis().cbegin()},
                           m_YItEnd{dataSeries.yAxis().cend()}
                 {
                 }
                 IteratorValue(const IteratorValue &other) = default;
                 std::unique_ptr<DataSeriesIteratorValue::Impl> clone() const override
                 {
                     return std::make_unique<IteratorValue<Dim, IsConst> >(*this);
                 }
                 int distance(const DataSeriesIteratorValue::Impl &other) const override try {
                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
                     return m_XIt->distance(*otherImpl.m_XIt);
                 }
                 catch (const std::bad_cast &) {
                     return 0;
                 }
                 bool equals(const DataSeriesIteratorValue::Impl &other) const override try {
                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
                     return std::tie(m_XIt, m_ValuesIt, m_YItBegin, m_YItEnd)
                            == std::tie(otherImpl.m_XIt, otherImpl.m_ValuesIt, otherImpl.m_YItBegin,
                                        otherImpl.m_YItEnd);
                 }
                 catch (const std::bad_cast &) {
                     return false;
                 }
                 bool lowerThan(const DataSeriesIteratorValue::Impl &other) const override try {
                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
                     return m_XIt->lowerThan(*otherImpl.m_XIt);
                 }
                 catch (const std::bad_cast &) {
                     return false;
                 }
                 std::unique_ptr<DataSeriesIteratorValue::Impl> advance(int offset) const override
                 {
                     auto result = clone();
                     result->next(offset);
                     return result;
                 }
                 void next(int offset) override
                 {
                     m_XIt->next(offset);
                     m_ValuesIt->next(offset);
                 }
                 void prev() override
                 {
                     --m_XIt;
                     --m_ValuesIt;
                 }
                 double x() const override { return m_XIt->at(0); }
                 std::vector<double> y() const override
                 {
                     std::vector<double> result{};
                     std::transform(m_YItBegin, m_YItEnd, std::back_inserter(result),
                                    [](const auto &it) { return it.first(); });
                     return result;
                 }
                 double value() const override { return m_ValuesIt->at(0); }
                 double value(int componentIndex) const override { return m_ValuesIt->at(componentIndex); }
                 double minValue() const override { return m_ValuesIt->min(); }
                 double maxValue() const override { return m_ValuesIt->max(); }
                 QVector<double> values() const override { return m_ValuesIt->values(); }
                 void swap(DataSeriesIteratorValue::Impl &other) override
                 {
                     auto &otherImpl = dynamic_cast<IteratorValue &>(other);
                     m_XIt->impl()->swap(*otherImpl.m_XIt->impl());
                     m_ValuesIt->impl()->swap(*otherImpl.m_ValuesIt->impl());
                     m_YItBegin->impl()->swap(*otherImpl.m_YItBegin->impl());
                     m_YItEnd->impl()->swap(*otherImpl.m_YItEnd->impl());
                 }
             private:
                 ArrayDataIterator m_XIt;
                 ArrayDataIterator m_ValuesIt;
                 ArrayDataIterator m_YItBegin;
                 ArrayDataIterator m_YItEnd;
             };
             } // namespace dataseries_detail
             /**
              * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
              *
              * The DataSeries represents values on one or two axes, according to these rules:
              * - the x-axis is always defined
              * - an y-axis can be defined or not. If set, additional consistency checks apply to the values (see
              * below)
              * - the values are defined on one or two dimensions. In the case of 2-dim values, the data is
              * distributed into components (for example, a vector defines three components)
              * - New values can be added to the series, on the x-axis.
              * - Once initialized to the series creation, the y-axis (if defined) is no longer modifiable
              * - Data representing values and axes are associated with a unit
              * - The data series is always sorted in ascending order on the x-axis.
              *
              * Consistency checks are carried out between the axes and the values. These controls are provided
              * throughout the DataSeries lifecycle:
              * - the number of data on the x-axis must be equal to the number of values (in the case of
              * 2-dim ArrayData for values, the test is performed on the number of values per component)
              * - if the y-axis is defined, the number of components of the ArrayData for values must equal the
              * number of data on the y-axis.
              *
              * Examples:
              * 1)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: not defined
              * - values: [10 ; 20 ; 30] (1-dim ArrayData)
              * => the DataSeries is valid, as x-axis and values have the same number of data
              *
              * 2)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: not defined
              * - values: [10 ; 20 ; 30 ; 40] (1-dim ArrayData)
              * => the DataSeries is invalid, as x-axis and values haven't the same number of data
              *
              * 3)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: not defined
              * - values: [10 ; 20 ; 30
              *            40 ; 50 ; 60] (2-dim ArrayData)
              * => the DataSeries is valid, as x-axis has 3 data and values contains 2 components with 3
              * data each
              *
              * 4)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: [1 ; 2]
              * - values: [10 ; 20 ; 30
              *            40 ; 50 ; 60] (2-dim ArrayData)
              * => the DataSeries is valid, as:
              * - x-axis has 3 data and values contains 2 components with 3 data each AND
              * - y-axis has 2 data and values contains 2 components
              *
              * 5)
              * - x-axis: [1 ; 2 ; 3]
              * - y-axis: [1 ; 2 ; 3]
              * - values: [10 ; 20 ; 30
              *            40 ; 50 ; 60] (2-dim ArrayData)
              * => the DataSeries is invalid, as:
              * - x-axis has 3 data and values contains 2 components with 3 data each BUT
              * - y-axis has 3 data and values contains only 2 components
              *
              * @tparam Dim The dimension of the values data
              *
              */
             template <int Dim>
             class SCIQLOP_CORE_EXPORT DataSeries : public IDataSeries {
                 friend class DataSeriesMergeHelper;
             public:
                 /// @sa IDataSeries::xAxisData()
                 std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
                 const std::shared_ptr<ArrayData<1> > xAxisData() const override { return m_XAxisData; }
                 /// @sa IDataSeries::xAxisUnit()
                 Unit xAxisUnit() const override { return m_XAxisUnit; }
                 /// @sa IDataSeries::yAxisUnit()
                 Unit yAxisUnit() const override { return m_YAxis.unit(); }
                 /// @return the values dataset
                 std::shared_ptr<ArrayData<Dim> > valuesData() { return m_ValuesData; }
                 const std::shared_ptr<ArrayData<Dim> > valuesData() const { return m_ValuesData; }
                 /// @sa IDataSeries::valuesUnit()
                 Unit valuesUnit() const override { return m_ValuesUnit; }
                 int nbPoints() const override { return m_ValuesData->totalSize(); }
                 std::pair<double, double> yBounds() const override { return m_YAxis.bounds(); }
                 void clear()
                 {
                     m_XAxisData->clear();
                     m_ValuesData->clear();
                 }
                 bool isEmpty() const noexcept { return m_XAxisData->size() == 0; }
                 /// Merges into the data series an other data series.
                 ///
                 /// The two dataseries:
                 /// - must be of the same dimension
                 /// - must have the same y-axis (if defined)
                 ///
                 /// If the prerequisites are not valid, the method does nothing
                 ///
                 /// @remarks the data series to merge with is cleared after the operation
                 void merge(IDataSeries *dataSeries) override
                 {
                     dataSeries->lockWrite();
                     lockWrite();
                     if (auto other = dynamic_cast<DataSeries<Dim> *>(dataSeries)) {
                         if (m_YAxis == other->m_YAxis) {
                             DataSeriesMergeHelper::merge(*other, *this);
                         }
                         else {
                             qCWarning(LOG_DataSeries())
                                 << QObject::tr("Can't merge data series that have not the same y-axis");
                         }
                     }
                     else {
                         qCWarning(LOG_DataSeries())
                             << QObject::tr("Detection of a type of IDataSeries we cannot merge with !");
                     }
                     unlock();
                     dataSeries->unlock();
                 }
                 void purge(double min, double max) override
                 {
                     // Nothing to purge if series is empty
                     if (isEmpty()) {
                         return;
                     }
                     if (min > max) {
                         std::swap(min, max);
                     }
                     // Nothing to purge if series min/max are inside purge range
                     auto xMin = cbegin()->x();
                     auto xMax = (--cend())->x();
                     if (xMin >= min && xMax <= max) {
                         return;
                     }
                     auto lowerIt = std::lower_bound(
                         begin(), end(), min, [](const auto &it, const auto &val) { return it.x() < val; });
                     erase(begin(), lowerIt);
                     auto upperIt = std::upper_bound(
                         begin(), end(), max, [](const auto &val, const auto &it) { return val < it.x(); });
                     erase(upperIt, end());
                 }
                 // ///////// //
                 // Iterators //
                 // ///////// //
                 DataSeriesIterator begin() override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim, false> >(*this, true)}};
                 }
                 DataSeriesIterator end() override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim, false> >(*this, false)}};
                 }
                 DataSeriesIterator cbegin() const override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim, true> >(*this, true)}};
                 }
                 DataSeriesIterator cend() const override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim, true> >(*this, false)}};
                 }
-                void erase(DataSeriesIterator first, DataSeriesIterator last)
+                virtual void erase(DataSeriesIterator first, DataSeriesIterator last)
                 {
                     auto firstImpl
                         = dynamic_cast<dataseries_detail::IteratorValue<Dim, false> *>(first->impl());
                     auto lastImpl = dynamic_cast<dataseries_detail::IteratorValue<Dim, false> *>(last->impl());
                     if (firstImpl && lastImpl) {
                         m_XAxisData->erase(firstImpl->m_XIt, lastImpl->m_XIt);
                         m_ValuesData->erase(firstImpl->m_ValuesIt, lastImpl->m_ValuesIt);
                     }
                 }
-                void insert(DataSeriesIterator first, DataSeriesIterator last, bool prepend = false)
+                virtual void insert(DataSeriesIterator first, DataSeriesIterator last, bool prepend = false)
                 {
                     auto firstImpl = dynamic_cast<dataseries_detail::IteratorValue<Dim, true> *>(first->impl());
                     auto lastImpl = dynamic_cast<dataseries_detail::IteratorValue<Dim, true> *>(last->impl());
                     if (firstImpl && lastImpl) {
                         m_XAxisData->insert(firstImpl->m_XIt, lastImpl->m_XIt, prepend);
                         m_ValuesData->insert(firstImpl->m_ValuesIt, lastImpl->m_ValuesIt, prepend);
                     }
                 }
                 /// @sa IDataSeries::minXAxisData()
                 DataSeriesIterator minXAxisData(double minXAxisData) const override
                 {
                     return std::lower_bound(
                         cbegin(), cend(), minXAxisData,
                         [](const auto &itValue, const auto &value) { return itValue.x() < value; });
                 }
                 /// @sa IDataSeries::maxXAxisData()
                 DataSeriesIterator maxXAxisData(double maxXAxisData) const override
                 {
                     // Gets the first element that greater than max value
                     auto it = std::upper_bound(
                         cbegin(), cend(), maxXAxisData,
                         [](const auto &value, const auto &itValue) { return value < itValue.x(); });
                     return it == cbegin() ? cend() : --it;
                 }
                 std::pair<DataSeriesIterator, DataSeriesIterator> xAxisRange(double minXAxisData,
                                                                              double maxXAxisData) const override
                 {
                     if (minXAxisData > maxXAxisData) {
                         std::swap(minXAxisData, maxXAxisData);
                     }
                     auto begin = cbegin();
                     auto end = cend();
                     auto lowerIt = std::lower_bound(
                         begin, end, minXAxisData,
                         [](const auto &itValue, const auto &value) { return itValue.x() < value; });
                     auto upperIt = std::upper_bound(
                         lowerIt, end, maxXAxisData,
                         [](const auto &value, const auto &itValue) { return value < itValue.x(); });
                     return std::make_pair(lowerIt, upperIt);
                 }
                 std::pair<DataSeriesIterator, DataSeriesIterator>
                 valuesBounds(double minXAxisData, double maxXAxisData) const override
                 {
                     // Places iterators to the correct x-axis range
                     auto xAxisRangeIts = xAxisRange(minXAxisData, maxXAxisData);
                     // Returns end iterators if the range is empty
                     if (xAxisRangeIts.first == xAxisRangeIts.second) {
                         return std::make_pair(cend(), cend());
                     }
                     // Gets the iterator on the min of all values data
                     auto minIt = std::min_element(
                         xAxisRangeIts.first, xAxisRangeIts.second, [](const auto &it1, const auto &it2) {
                             return SortUtils::minCompareWithNaN(it1.minValue(), it2.minValue());
                         });
                     // Gets the iterator on the max of all values data
                     auto maxIt = std::max_element(
                         xAxisRangeIts.first, xAxisRangeIts.second, [](const auto &it1, const auto &it2) {
                             return SortUtils::maxCompareWithNaN(it1.maxValue(), it2.maxValue());
                         });
                     return std::make_pair(minIt, maxIt);
                 }
                 /// @return the y-axis associated to the data series
                 const OptionalAxis &yAxis() const { return m_YAxis; }
                 OptionalAxis &yAxis() { return m_YAxis; }
                 // /////// //
                 // Mutexes //
                 // /////// //
                 virtual QReadLocker getReadLock() override { return QReadLocker{&m_Lock}; }
                 virtual QWriteLocker getWriteLock() override { return QWriteLocker{&m_Lock}; }
                 virtual void lockRead() override { m_Lock.lockForRead(); }
                 virtual void lockWrite() override { m_Lock.lockForWrite(); }
                 virtual void unlock() override { m_Lock.unlock(); }
             protected:
                 /// Protected ctor (DataSeries is abstract).
                 ///
                 /// Data vectors must be consistent with each other, otherwise an exception will be thrown (@sa
                 /// class description for consistent rules)
                 /// @remarks data series is automatically sorted on its x-axis data
                 /// @throws std::invalid_argument if the data are inconsistent with each other
                 explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
                                     std::shared_ptr<ArrayData<Dim> > valuesData, const Unit &valuesUnit,
                                     OptionalAxis yAxis = OptionalAxis{})
                         : m_XAxisData{xAxisData},
                           m_XAxisUnit{xAxisUnit},
                           m_ValuesData{valuesData},
                           m_ValuesUnit{valuesUnit},
                           m_YAxis{std::move(yAxis)}
                 {
                     if (m_XAxisData->size() != m_ValuesData->size()) {
                         throw std::invalid_argument{
                             "The number of values by component must be equal to the number of x-axis data"};
                     }
                     // Validates y-axis (if defined)
                     if (yAxis.isDefined() && (yAxis.size() != m_ValuesData->componentCount())) {
                         throw std::invalid_argument{
                             "As the y-axis is defined, the number of value components must be equal to the "
                             "number of y-axis data"};
                     }
                     // Sorts data if it's not the case
                     const auto &xAxisCData = m_XAxisData->cdata();
                     if (!std::is_sorted(xAxisCData.cbegin(), xAxisCData.cend())) {
                         sort();
                     }
                 }
                 /// Copy ctor
                 explicit DataSeries(const DataSeries<Dim> &other)
                         : m_XAxisData{std::make_shared<ArrayData<1> >(*other.m_XAxisData)},
                           m_XAxisUnit{other.m_XAxisUnit},
                           m_ValuesData{std::make_shared<ArrayData<Dim> >(*other.m_ValuesData)},
                           m_ValuesUnit{other.m_ValuesUnit},
                           m_YAxis{other.m_YAxis}
                 {
                     // Since a series is ordered from its construction and is always ordered, it is not
                     // necessary to call the sort method here ('other' is sorted)
                 }
                 /// Assignment operator
                 template <int D>
                 DataSeries &operator=(DataSeries<D> other)
                 {
                     std::swap(m_XAxisData, other.m_XAxisData);
                     std::swap(m_XAxisUnit, other.m_XAxisUnit);
                     std::swap(m_ValuesData, other.m_ValuesData);
                     std::swap(m_ValuesUnit, other.m_ValuesUnit);
                     std::swap(m_YAxis, other.m_YAxis);
                     return *this;
                 }
             private:
                 /**
                  * Sorts data series on its x-axis data
                  */
                 void sort() noexcept
                 {
                     auto permutation = SortUtils::sortPermutation(*m_XAxisData, std::less<double>());
                     m_XAxisData = m_XAxisData->sort(permutation);
                     m_ValuesData = m_ValuesData->sort(permutation);
                 }
                 // x-axis
                 std::shared_ptr<ArrayData<1> > m_XAxisData;
                 Unit m_XAxisUnit;
                 // values
                 std::shared_ptr<ArrayData<Dim> > m_ValuesData;
                 Unit m_ValuesUnit;
                 // y-axis (optional)
                 OptionalAxis m_YAxis;
                 QReadWriteLock m_Lock;
             };
             #endif // SCIQLOP_DATASERIES_H

include/Data/SpectrogramSeries.h +19 0

             #ifndef SCIQLOP_SPECTROGRAMSERIES_H
             #define SCIQLOP_SPECTROGRAMSERIES_H
             #include "CoreGlobal.h"
             #include <Data/DataSeries.h>
             /**
              * @brief The SpectrogramSeries class is the implementation for a data series representing a
              * spectrogram.
              *
              * It defines values on a x-axis and a y-axis.
              */
             class SCIQLOP_CORE_EXPORT SpectrogramSeries : public DataSeries<2> {
             public:
                 /// Ctor
                 explicit SpectrogramSeries(std::vector<double> xAxisData, std::vector<double> yAxisData,
                                            std::vector<double> valuesData, const Unit &xAxisUnit,
                                            const Unit &yAxisUnit, const Unit &valuesUnit,
                                            double xResolution = std::numeric_limits<double>::quiet_NaN());
                 /// Ctor directly with the y-axis
                 explicit SpectrogramSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
                                            std::shared_ptr<ArrayData<2> > valuesData, const Unit &valuesUnit,
                                            OptionalAxis yAxis,
                                            double xResolution = std::numeric_limits<double>::quiet_NaN());
                 /// @sa DataSeries::clone()
                 std::unique_ptr<IDataSeries> clone() const override;
                 /// @sa DataSeries::subDataSeries()
                 std::shared_ptr<IDataSeries> subDataSeries(const DateTimeRange &range) override;
                 inline double xResolution() const noexcept { return m_XResolution; }
+                void erase(DataSeriesIterator first, DataSeriesIterator last) override
+                {
+                    DataSeries<2>::erase(first,last);
+                    updateResolution();
+                }
+                void insert(DataSeriesIterator first, DataSeriesIterator last, bool prepend = false) override
+                {
+                    DataSeries<2>::insert(first,last, prepend);
+                    updateResolution();
+                }
+                void merge(IDataSeries *dataSeries) override
+                {
+                    DataSeries<2>::merge(dataSeries);
+                    updateResolution();
+                }
             private:
+                void updateResolution();
                 double m_XResolution; ///< Resolution used on x-axis to build the spectrogram
             };
             #endif // SCIQLOP_SPECTROGRAMSERIES_H

src/Data/SpectrogramSeries.cpp +7 -1

             #include <Data/SpectrogramSeries.h>
             #include <Data/DataSeriesUtils.h>
             SpectrogramSeries::SpectrogramSeries(std::vector<double> xAxisData, std::vector<double> yAxisData,
                                                  std::vector<double> valuesData, const Unit &xAxisUnit,
                                                  const Unit &yAxisUnit, const Unit &valuesUnit,
                                                  double resolution)
                     : SpectrogramSeries{
                           std::make_shared<ArrayData<1> >(std::move(xAxisData)),
                           xAxisUnit,
                           std::make_shared<ArrayData<2> >(std::move(valuesData), yAxisData.size()),
                           valuesUnit,
                           OptionalAxis{std::make_shared<ArrayData<1> >(std::move(yAxisData)), yAxisUnit},
                           resolution}
             {
             }
             SpectrogramSeries::SpectrogramSeries(std::shared_ptr<ArrayData<1> > xAxisData,
                                                  const Unit &xAxisUnit,
                                                  std::shared_ptr<ArrayData<2> > valuesData,
                                                  const Unit &valuesUnit, OptionalAxis yAxis, double resolution)
                     : DataSeries{std::move(xAxisData), xAxisUnit, std::move(valuesData), valuesUnit,
                                  std::move(yAxis)},
                       m_XResolution{resolution}
             {
                 if(std::isnan(m_XResolution))
                 {
-                    //m_XResolution = DataSeriesUtils::resolution(xAxisData->begin(), xAxisData->end()).m_Val;
+                    updateResolution();
                 }
             }
             std::unique_ptr<IDataSeries> SpectrogramSeries::clone() const
             {
                 return std::make_unique<SpectrogramSeries>(*this);
             }
             std::shared_ptr<IDataSeries> SpectrogramSeries::subDataSeries(const DateTimeRange &range)
             {
                 auto subXAxisData = std::vector<double>();
                 auto subValuesData = QVector<double>(); // Uses QVector to append easily values to it
                 this->lockRead();
                 auto bounds = xAxisRange(range.m_TStart, range.m_TEnd);
                 for (auto it = bounds.first; it != bounds.second; ++it) {
                     subXAxisData.push_back(it->x());
                     subValuesData.append(it->values());
                 }
                 auto yAxis = this->yAxis();
                 this->unlock();
                 return std::make_shared<SpectrogramSeries>(
                     std::make_shared<ArrayData<1> >(std::move(subXAxisData)), this->xAxisUnit(),
                     std::make_shared<ArrayData<2> >(subValuesData.toStdVector(), yAxis.size()),
                     this->valuesUnit(), std::move(yAxis));
             }
+            void SpectrogramSeries::updateResolution()
+            {
+                auto xAxisData = this->xAxisData()->cdata();
+                m_XResolution = DataSeriesUtils::resolution(xAxisData.begin(), xAxisData.end()).m_Val;
+            }

src/pybind11_wrappers/CoreWrappers.cpp +6 -1

             #include <pybind11/pybind11.h>
             #include <pybind11/operators.h>
             #include <pybind11/embed.h>
             #include <pybind11/numpy.h>
             #include <pybind11/chrono.h>
             #include <pybind11/functional.h>
             #include <pybind11/stl.h>
             #include <string>
             #include <sstream>
             #include "pywrappers_common.h"
             #include "CoreWrappers.h"
             #include <Data/DataSeriesType.h>
             #include <Data/ScalarSeries.h>
             #include <Data/VectorSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/Unit.h>
             #include <Data/OptionalAxis.h>
             #include <Data/IDataProvider.h>
             #include <Variable/VariableController2.h>
             #include <Time/TimeController.h>
             #include <Network/Downloader.h>
             namespace py = pybind11;
             using namespace std::chrono;
             PYBIND11_MODULE(pysciqlopcore,m){
                 py::enum_<DataSeriesType>(m, "DataSeriesType")
                         .value("SCALAR", DataSeriesType::SCALAR)
                         .value("SPECTROGRAM", DataSeriesType::SPECTROGRAM)
                         .value("VECTOR", DataSeriesType::VECTOR)
                         .value("UNKNOWN", DataSeriesType::UNKNOWN)
                         .export_values();
                 py::class_<Unit>(m, "Unit")
                         .def_readwrite("name", &Unit::m_Name)
                         .def_readwrite("time_unit", &Unit::m_TimeUnit)
                         .def(py::self == py::self)
                         .def(py::self != py::self)
                         .def("__repr__",__repr__<Unit>);
                 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_<ArrayDataIteratorValue>(m, "ArrayDataIteratorValue")
                         .def_property_readonly("value", &ArrayDataIteratorValue::first);
                 py::class_<OptionalAxis>(m, "OptionalAxis")
                         .def("__len__", &OptionalAxis::size)
                         .def_property_readonly("size", &OptionalAxis::size)
                         .def("__getitem__", [](OptionalAxis& ax, int key) {
                                 return (*(ax.begin()+key)).first();
                             }, py::is_operator())
                         .def("__iter__", [](OptionalAxis& ax) {
                                 return py::make_iterator(ax.begin(), ax.end());
                             }, py::keep_alive<0, 1>());
                 py::class_<DataSeriesIteratorValue>(m,"DataSeriesIteratorValue")
                         .def_property_readonly("x", &DataSeriesIteratorValue::x)
                         .def_property_readonly("y", &DataSeriesIteratorValue::y)
                         .def("value", py::overload_cast<>(&DataSeriesIteratorValue::value, py::const_))
                         .def("value", py::overload_cast<int>(&DataSeriesIteratorValue::value, py::const_))
                         .def("values", &DataSeriesIteratorValue::values);
                 py::class_<IDataSeries, std::shared_ptr<IDataSeries>>(m, "IDataSeries")
                         .def("nbPoints", &IDataSeries::nbPoints)
                         .def_property_readonly("xAxisUnit", &IDataSeries::xAxisUnit)
                         .def_property_readonly("yAxisUnit", &IDataSeries::yAxisUnit)
                         .def_property_readonly("valuesUnit", &IDataSeries::valuesUnit)
                         .def("__getitem__", [](IDataSeries& serie, int key) {
                     return *(serie.begin()+key);
                 }, py::is_operator())
                         .def("__len__", &IDataSeries::nbPoints)
                         .def("__iter__", [](IDataSeries& serie) {
                     return py::make_iterator(serie.begin(), serie.end());
                 }, py::keep_alive<0, 1>())
                         .def("__repr__",__repr__<IDataSeries>);
+                py::class_<ArrayData<1>, std::shared_ptr<ArrayData<1>> >(m,"ArrayData1d")
+                        .def("cdata", [](ArrayData<1>& array) {return array.cdata();});
                 py::class_<ScalarSeries, std::shared_ptr<ScalarSeries>, IDataSeries>(m, "ScalarSeries")
                         .def("nbPoints", &ScalarSeries::nbPoints);
                 py::class_<VectorSeries, std::shared_ptr<VectorSeries>, IDataSeries>(m, "VectorSeries")
                         .def("nbPoints", &VectorSeries::nbPoints);
                 py::class_<DataSeries<2>, std::shared_ptr<DataSeries<2>>, IDataSeries>(m,"DataSeries2d")
+                        .def_property_readonly("xAxis", py::overload_cast<>(&DataSeries<2>::xAxisData, py::const_))
                         .def_property_readonly("yAxis", py::overload_cast<>(&DataSeries<2>::yAxis, py::const_));
                 py::class_<SpectrogramSeries, std::shared_ptr<SpectrogramSeries>, DataSeries<2>>(m, "SpectrogramSeries")
-                        .def("nbPoints", &SpectrogramSeries::nbPoints);
+                        .def("nbPoints", &SpectrogramSeries::nbPoints)
+                        .def("xRes", &SpectrogramSeries::xResolution);
                 py::class_<IDataProvider, std::shared_ptr<IDataProvider>>(m, "IDataProvider");
                 py::class_<Variable,std::shared_ptr<Variable>>(m, "Variable")
                         .def(py::init<const QString&>())
                         .def_property("name", &Variable::name, &Variable::setName)
                         .def_property("range", &Variable::range, &Variable::setRange)
                         .def_property("cacheRange", &Variable::cacheRange, &Variable::setCacheRange)
                         .def_property_readonly("nbPoints", &Variable::nbPoints)
                         .def_property_readonly("dataSeries", &Variable::dataSeries)
                         .def("__len__", [](Variable& variable) {
                     auto rng = variable.dataSeries()->xAxisRange(variable.range().m_TStart,variable.range().m_TEnd);
                     return std::distance(rng.first,rng.second);
                 })
                         .def("__iter__", [](Variable& variable) {
                     auto rng = variable.dataSeries()->xAxisRange(variable.range().m_TStart,variable.range().m_TEnd);
                     return py::make_iterator(rng.first, rng.second);
                 }, py::keep_alive<0, 1>())
                         .def("__getitem__", [](Variable& variable, int key) {
                     //insane and slow!
                     auto rng = variable.dataSeries()->xAxisRange(variable.range().m_TStart,variable.range().m_TEnd);
                     if(key<0)
                         return *(rng.second+key);
                     else
                         return *(rng.first+key);
                 })
                         .def("__repr__",__repr__<Variable>);
                 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_ = 0.001 * duration_cast<milliseconds>(start.time_since_epoch()).count();
                                  double stop_ = 0.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