GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r614:d53842017d03

Merge branch 'feature/ValueRange' into develop

Alexandre Leroux -

r614:d53842017d03

parent child

Context file:

r614:d53842017d03

Collapse all files

core/include/Common/SortUtils.h +52 0

             #ifndef SCIQLOP_SORTUTILS_H
             #define SCIQLOP_SORTUTILS_H
             #include <algorithm>
             #include <numeric>
             #include <vector>
             /**
              * Utility class with methods for sorting data
              */
             struct SortUtils {
                 /**
                  * Generates a vector representing the index of insertion of each data of a container if this
                  * one had to be sorted according to a comparison function.
                  *
                  * For example:
                  * If the container is a vector {1; 4; 2; 5; 3} and the comparison function is std::less, the
                  * result would be : {0; 3; 1; 4; 2}
                  *
                  * @tparam Container the type of the container.
                  * @tparam Compare the type of the comparison function
                  * @param container the container from which to generate the result. The container must have a
                  * at() method that returns a value associated to an index
                  * @param compare the comparison function
                  */
                 template <typename Container, typename Compare>
                 static std::vector<int> sortPermutation(const Container &container, const Compare &compare)
                 {
                     auto permutation = std::vector<int>{};
                     permutation.resize(container.size());
                     std::iota(permutation.begin(), permutation.end(), 0);
                     std::sort(permutation.begin(), permutation.end(),
                               [&](int i, int j) { return compare(container.at(i), container.at(j)); });
                     return permutation;
                 }
                 /**
                  * Sorts a container according to indices passed in parameter
                  * @param container the container sorted
                  * @param sortPermutation the indices used to sort the container
                  * @return the container sorted
                  * @warning no verification is made on validity of sortPermutation (i.e. the vector has unique
                  * indices and its range is [0 ; vector.size()[ )
                  */
                 template <typename Container>
                 static Container sort(const Container &container, const std::vector<int> &sortPermutation)
                 {
                     if (container.size() != sortPermutation.size()) {
                         return Container{};
                     }
                     // Inits result
                     auto sortedData = Container{};
                     sortedData.resize(container.size());
                     std::transform(sortPermutation.cbegin(), sortPermutation.cend(), sortedData.begin(),
                                    [&container](int i) { return container.at(i); });
                     return sortedData;
                 }
+                /**
+                 * Compares two values that can be NaN. This method is intended to be used as a compare function
+                 * for searching min value by excluding NaN values.
+                 *
+                 * Examples of use:
+                 * - f({1, 3, 2, 4, 5}) will return 1
+                 * - f({NaN, 3, 2, 4, 5}) will return 2 (NaN is excluded)
+                 * - f({NaN, NaN, 3, NaN, NaN}) will return 3 (NaN are excluded)
+                 * - f({NaN, NaN, NaN, NaN, NaN}) will return NaN (no existing value)
+                 *
+                 * @param v1 first value
+                 * @param v2 second value
+                 * @return true if v1 < v2, false otherwise
+                 * @sa std::min_element
+                 */
+                template <typename T>
+                static bool minCompareWithNaN(const T &v1, const T &v2)
+                {
+                    // Table used with NaN values:
+                    // NaN < v2 -> false
+                    // v1 < NaN -> true
+                    // NaN < NaN -> false
+                    // v1 < v2 -> v1 < v2
+                    return std::isnan(v1) ? false : std::isnan(v2) || (v1 < v2);
+                }
+                /**
+                 * Compares two values that can be NaN. This method is intended to be used as a compare function
+                 * for searching max value by excluding NaN values.
+                 *
+                 * Examples of use:
+                 * - f({1, 3, 2, 4, 5}) will return 5
+                 * - f({1, 3, 2, 4, NaN}) will return 4 (NaN is excluded)
+                 * - f({NaN, NaN, 3, NaN, NaN}) will return 3 (NaN are excluded)
+                 * - f({NaN, NaN, NaN, NaN, NaN}) will return NaN (no existing value)
+                 *
+                 * @param v1 first value
+                 * @param v2 second value
+                 * @return true if v1 < v2, false otherwise
+                 * @sa std::max_element
+                 */
+                template <typename T>
+                static bool maxCompareWithNaN(const T &v1, const T &v2)
+                {
+                    // Table used with NaN values:
+                    // NaN < v2 -> true
+                    // v1 < NaN -> false
+                    // NaN < NaN -> false
+                    // v1 < v2 -> v1 < v2
+                    return std::isnan(v1) ? true : !std::isnan(v2) && (v1 < v2);
+                }
             };
             #endif // SCIQLOP_SORTUTILS_H

core/include/Data/ArrayData.h +20 0

             #ifndef SCIQLOP_ARRAYDATA_H
             #define SCIQLOP_ARRAYDATA_H
             #include <Common/SortUtils.h>
             #include <QReadLocker>
             #include <QReadWriteLock>
             #include <QVector>
             #include <memory>
             template <int Dim>
             class ArrayData;
             using DataContainer = QVector<QVector<double> >;
             namespace arraydata_detail {
             /// Struct used to sort ArrayData
             template <int Dim>
             struct Sort {
                 static std::shared_ptr<ArrayData<Dim> > sort(const DataContainer &data,
                                                              const std::vector<int> &sortPermutation)
                 {
                     auto nbComponents = data.size();
                     auto sortedData = DataContainer(nbComponents);
                     for (auto i = 0; i < nbComponents; ++i) {
                         sortedData[i] = SortUtils::sort(data.at(i), sortPermutation);
                     }
                     return std::make_shared<ArrayData<Dim> >(std::move(sortedData));
                 }
             };
             /// Specialization for uni-dimensional ArrayData
             template <>
             struct Sort<1> {
                 static std::shared_ptr<ArrayData<1> > sort(const DataContainer &data,
                                                            const std::vector<int> &sortPermutation)
                 {
                     return std::make_shared<ArrayData<1> >(SortUtils::sort(data.at(0), sortPermutation));
                 }
             };
             } // namespace arraydata_detail
             /**
              * @brief The ArrayData class represents a dataset for a data series.
              *
              * A dataset can be unidimensional or two-dimensional. This property is determined by the Dim
              * template-parameter. In a case of a two-dimensional dataset, each dataset component has the same
              * number of values
              *
              * @tparam Dim the dimension of the ArrayData (one or two)
              * @sa IDataSeries
              */
             template <int Dim>
             class ArrayData {
             public:
                 class IteratorValue {
                 public:
                     explicit IteratorValue(const DataContainer &container, bool begin) : m_Its{}
                     {
                         for (auto i = 0; i < container.size(); ++i) {
                             m_Its.push_back(begin ? container.at(i).cbegin() : container.at(i).cend());
                         }
                     }
                     double at(int index) const { return *m_Its.at(index); }
                     double first() const { return *m_Its.front(); }
+                    /// @return the min value among all components
+                    double min() const
+                    {
+                        auto end = m_Its.cend();
+                        auto it = std::min_element(m_Its.cbegin(), end, [](const auto &it1, const auto &it2) {
+                            return SortUtils::minCompareWithNaN(*it1, *it2);
+                        });
+                        return it != end ? **it : std::numeric_limits<double>::quiet_NaN();
+                    }
+                    /// @return the max value among all components
+                    double max() const
+                    {
+                        auto end = m_Its.cend();
+                        auto it = std::max_element(m_Its.cbegin(), end, [](const auto &it1, const auto &it2) {
+                            return SortUtils::maxCompareWithNaN(*it1, *it2);
+                        });
+                        return it != end ? **it : std::numeric_limits<double>::quiet_NaN();
+                    }
                     void next()
                     {
                         for (auto &it : m_Its) {
                             ++it;
                         }
                     }
                     void prev()
                     {
                         for (auto &it : m_Its) {
                             --it;
                         }
                     }
                     bool operator==(const IteratorValue &other) const { return m_Its == other.m_Its; }
                 private:
                     std::vector<DataContainer::value_type::const_iterator> m_Its;
                 };
                 class Iterator {
                 public:
                     using iterator_category = std::forward_iterator_tag;
                     using value_type = const IteratorValue;
                     using difference_type = std::ptrdiff_t;
                     using pointer = value_type *;
                     using reference = value_type &;
                     Iterator(const DataContainer &container, bool begin) : m_CurrentValue{container, begin} {}
                     virtual ~Iterator() noexcept = default;
                     Iterator(const Iterator &) = default;
                     Iterator(Iterator &&) = default;
                     Iterator &operator=(const Iterator &) = default;
                     Iterator &operator=(Iterator &&) = default;
                     Iterator &operator++()
                     {
                         m_CurrentValue.next();
                         return *this;
                     }
                     Iterator &operator--()
                     {
                         m_CurrentValue.prev();
                         return *this;
                     }
                     pointer operator->() const { return &m_CurrentValue; }
                     reference operator*() const { return m_CurrentValue; }
                     bool operator==(const Iterator &other) const
                     {
                         return m_CurrentValue == other.m_CurrentValue;
                     }
                     bool operator!=(const Iterator &other) const { return !(*this == other); }
                 private:
                     IteratorValue m_CurrentValue;
                 };
                 // ///// //
                 // Ctors //
                 // ///// //
                 /**
                  * Ctor for a unidimensional ArrayData
                  * @param data the data the ArrayData will hold
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 explicit ArrayData(QVector<double> data) : m_Data{1, QVector<double>{}}
                 {
                     m_Data[0] = std::move(data);
                 }
                 /**
                  * Ctor for a two-dimensional ArrayData. The number of components (number of vectors) must be
                  * greater than 2 and each component must have the same number of values
                  * @param data the data the ArrayData will hold
                  * @throws std::invalid_argument if the number of components is less than 2
                  * @remarks if the number of values is not the same for each component, no value is set
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 2> >
                 explicit ArrayData(DataContainer data)
                 {
                     auto nbComponents = data.size();
                     if (nbComponents < 2) {
                         throw std::invalid_argument{
                             QString{"A multidimensional ArrayData must have at least 2 components (found: %1"}
                                 .arg(data.size())
                                 .toStdString()};
                     }
                     auto nbValues = data.front().size();
                     if (std::all_of(data.cbegin(), data.cend(), [nbValues](const auto &component) {
                             return component.size() == nbValues;
                         })) {
                         m_Data = std::move(data);
                     }
                     else {
                         m_Data = DataContainer{nbComponents, QVector<double>{}};
                     }
                 }
                 /// Copy ctor
                 explicit ArrayData(const ArrayData &other)
                 {
                     QReadLocker otherLocker{&other.m_Lock};
                     m_Data = other.m_Data;
                 }
                 // /////////////// //
                 // General methods //
                 // /////////////// //
                 /**
                  * Merges into the array data an other array data. The two array datas must have the same number
                  * of components so the merge can be done
                  * @param other the array data to merge with
                  * @param prepend if true, the other array data is inserted at the beginning, otherwise it is
                  * inserted at the end
                  */
                 void add(const ArrayData<Dim> &other, bool prepend = false)
                 {
                     QWriteLocker locker{&m_Lock};
                     QReadLocker otherLocker{&other.m_Lock};
                     auto nbComponents = m_Data.size();
                     if (nbComponents != other.m_Data.size()) {
                         return;
                     }
                     for (auto componentIndex = 0; componentIndex < nbComponents; ++componentIndex) {
                         if (prepend) {
                             const auto &otherData = other.data(componentIndex);
                             const auto otherDataSize = otherData.size();
                             auto &data = m_Data[componentIndex];
                             data.insert(data.begin(), otherDataSize, 0.);
                             for (auto i = 0; i < otherDataSize; ++i) {
                                 data.replace(i, otherData.at(i));
                             }
                         }
                         else {
                             m_Data[componentIndex] += other.data(componentIndex);
                         }
                     }
                 }
                 void clear()
                 {
                     QWriteLocker locker{&m_Lock};
                     auto nbComponents = m_Data.size();
                     for (auto i = 0; i < nbComponents; ++i) {
                         m_Data[i].clear();
                     }
                 }
                 int componentCount() const noexcept { return m_Data.size(); }
                 /**
                  * @return the data of a component
                  * @param componentIndex the index of the component to retrieve the data
                  * @return the component's data, empty vector if the index is invalid
                  */
                 QVector<double> data(int componentIndex) const noexcept
                 {
                     QReadLocker locker{&m_Lock};
                     return (componentIndex >= 0 && componentIndex < m_Data.size()) ? m_Data.at(componentIndex)
                                                                                    : QVector<double>{};
                 }
                 /// @return the size (i.e. number of values) of a single component
                 /// @remarks in a case of a two-dimensional ArrayData, each component has the same size
                 int size() const
                 {
                     QReadLocker locker{&m_Lock};
                     return m_Data[0].size();
                 }
                 std::shared_ptr<ArrayData<Dim> > sort(const std::vector<int> &sortPermutation)
                 {
                     QReadLocker locker{&m_Lock};
                     return arraydata_detail::Sort<Dim>::sort(m_Data, sortPermutation);
                 }
                 // ///////// //
                 // Iterators //
                 // ///////// //
                 Iterator cbegin() const { return Iterator{m_Data, true}; }
                 Iterator cend() const { return Iterator{m_Data, false}; }
                 // ///////////// //
                 // 1-dim methods //
                 // ///////////// //
                 /**
                  * @return the data at a specified index
                  * @remarks index must be a valid position
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 double at(int index) const noexcept
                 {
                     QReadLocker locker{&m_Lock};
                     return m_Data[0].at(index);
                 }
                 /**
                  * @return the data as a vector, as a const reference
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 const QVector<double> &cdata() const noexcept
                 {
                     QReadLocker locker{&m_Lock};
                     return m_Data.at(0);
                 }
                 /**
                  * @return the data as a vector
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 QVector<double> data() const noexcept
                 {
                     QReadLocker locker{&m_Lock};
                     return m_Data[0];
                 }
                 // ///////////// //
                 // 2-dim methods //
                 // ///////////// //
                 /**
                  * @return the data
                  * @remarks this method is only available for a two-dimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 2> >
                 DataContainer data() const noexcept
                 {
                     QReadLocker locker{&m_Lock};
                     return m_Data;
                 }
             private:
                 DataContainer m_Data;
                 mutable QReadWriteLock m_Lock;
             };
             #endif // SCIQLOP_ARRAYDATA_H

core/include/Data/DataSeries.h +42 -15

             #ifndef SCIQLOP_DATASERIES_H
             #define SCIQLOP_DATASERIES_H
             #include "CoreGlobal.h"
             #include <Common/SortUtils.h>
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.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>
             class IteratorValue : public DataSeriesIteratorValue::Impl {
             public:
                 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())
                 {
                 }
                 IteratorValue(const IteratorValue &other) = default;
                 std::unique_ptr<DataSeriesIteratorValue::Impl> clone() const override
                 {
                     return std::make_unique<IteratorValue<Dim> >(*this);
                 }
                 bool equals(const DataSeriesIteratorValue::Impl &other) const override try {
                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
                     return std::tie(m_XIt, m_ValuesIt) == std::tie(otherImpl.m_XIt, otherImpl.m_ValuesIt);
                 }
                 catch (const std::bad_cast &) {
                     return false;
                 }
                 void next() override
                 {
                     ++m_XIt;
                     ++m_ValuesIt;
                 }
                 void prev() override
                 {
                     --m_XIt;
                     --m_ValuesIt;
                 }
                 double x() const override { return m_XIt->at(0); }
                 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(); }
             private:
                 ArrayData<1>::Iterator m_XIt;
                 typename ArrayData<Dim>::Iterator m_ValuesIt;
             };
             } // namespace dataseries_detail
             /**
              * @brief The DataSeries class is the base (abstract) implementation of IDataSeries.
              *
              * It proposes to set a dimension for the values data.
              *
              * A DataSeries is always sorted on its x-axis data.
              *
              * @tparam Dim The dimension of the values data
              *
              */
             template <int Dim>
             class SCIQLOP_CORE_EXPORT DataSeries : public IDataSeries {
             public:
                 /// @sa IDataSeries::xAxisData()
                 std::shared_ptr<ArrayData<1> > xAxisData() override { return m_XAxisData; }
                 const std::shared_ptr<ArrayData<1> > xAxisData() const { return m_XAxisData; }
                 /// @sa IDataSeries::xAxisUnit()
                 Unit xAxisUnit() const override { return m_XAxisUnit; }
                 /// @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; }
                 SqpRange range() const override
                 {
                     if (!m_XAxisData->cdata().isEmpty()) {
                         return SqpRange{m_XAxisData->cdata().first(), m_XAxisData->cdata().last()};
                     }
                     return SqpRange{};
                 }
                 void clear()
                 {
                     m_XAxisData->clear();
                     m_ValuesData->clear();
                 }
                 /// Merges into the data series an other data series
                 /// @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)) {
                         const auto &otherXAxisData = other->xAxisData()->cdata();
                         const auto &xAxisData = m_XAxisData->cdata();
                         // As data series are sorted, we can improve performances of merge, by call the sort
                         // method only if the two data series overlap.
                         if (!otherXAxisData.empty()) {
                             auto firstValue = otherXAxisData.front();
                             auto lastValue = otherXAxisData.back();
                             auto xAxisDataBegin = xAxisData.cbegin();
                             auto xAxisDataEnd = xAxisData.cend();
                             bool prepend;
                             bool sortNeeded;
                             if (std::lower_bound(xAxisDataBegin, xAxisDataEnd, firstValue) == xAxisDataEnd) {
                                 // Other data series if after data series
                                 prepend = false;
                                 sortNeeded = false;
                             }
                             else if (std::upper_bound(xAxisDataBegin, xAxisDataEnd, lastValue)
                                      == xAxisDataBegin) {
                                 // Other data series if before data series
                                 prepend = true;
                                 sortNeeded = false;
                             }
                             else {
                                 // The two data series overlap
                                 prepend = false;
                                 sortNeeded = true;
                             }
                             // Makes the merge
                             m_XAxisData->add(*other->xAxisData(), prepend);
                             m_ValuesData->add(*other->valuesData(), prepend);
                             if (sortNeeded) {
                                 sort();
                             }
                         }
                         // Clears the other data series
                         other->clear();
                     }
                     else {
                         qCWarning(LOG_DataSeries())
                             << QObject::tr("Detection of a type of IDataSeries we cannot merge with !");
                     }
                     unlock();
                     dataSeries->unlock();
                 }
                 // ///////// //
                 // Iterators //
                 // ///////// //
                 DataSeriesIterator cbegin() const override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim> >(*this, true)}};
                 }
                 DataSeriesIterator cend() const override
                 {
                     return DataSeriesIterator{DataSeriesIteratorValue{
                         std::make_unique<dataseries_detail::IteratorValue<Dim> >(*this, false)}};
                 }
-                /// @sa IDataSeries::minData()
+                /// @sa IDataSeries::minXAxisData()
-                DataSeriesIterator minData(double minXAxisData) const override
+                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::maxData()
+                /// @sa IDataSeries::maxXAxisData()
-                DataSeriesIterator maxData(double maxXAxisData) const override
+                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> subData(double min, double max) const override
+                std::pair<DataSeriesIterator, DataSeriesIterator> xAxisRange(double minXAxisData,
+                                                                             double maxXAxisData) const override
                 {
-                    if (min > max) {
+                    if (minXAxisData > maxXAxisData) {
-                        std::swap(min, max);
+                        std::swap(minXAxisData, maxXAxisData);
                     }
                     auto begin = cbegin();
                     auto end = cend();
-                    auto lowerIt
+                    auto lowerIt = std::lower_bound(
-                        = std::lower_bound(begin, end, min, [](const auto &itValue, const auto &value) {
+                        begin, end, minXAxisData,
-                              return itValue.x() < value;
+                        [](const auto &itValue, const auto &value) { return itValue.x() < value; });
-                          });
+                    auto upperIt = std::upper_bound(
-                    auto upperIt
+                        begin, end, maxXAxisData,
-                        = std::upper_bound(begin, end, max, [](const auto &value, const auto &itValue) {
+                        [](const auto &value, const auto &itValue) { return value < itValue.x(); });
-                              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);
+                }
                 // /////// //
                 // Mutexes //
                 // /////// //
                 virtual void lockRead() { m_Lock.lockForRead(); }
                 virtual void lockWrite() { m_Lock.lockForWrite(); }
                 virtual void unlock() { m_Lock.unlock(); }
             protected:
                 /// Protected ctor (DataSeries is abstract). The vectors must have the same size, otherwise a
                 /// DataSeries with no values will be created.
                 /// @remarks data series is automatically sorted on its x-axis data
                 explicit DataSeries(std::shared_ptr<ArrayData<1> > xAxisData, const Unit &xAxisUnit,
                                     std::shared_ptr<ArrayData<Dim> > valuesData, const Unit &valuesUnit)
                         : m_XAxisData{xAxisData},
                           m_XAxisUnit{xAxisUnit},
                           m_ValuesData{valuesData},
                           m_ValuesUnit{valuesUnit}
                 {
                     if (m_XAxisData->size() != m_ValuesData->size()) {
                         clear();
                     }
                     // 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}
                 {
                     // 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);
                     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);
                 }
                 std::shared_ptr<ArrayData<1> > m_XAxisData;
                 Unit m_XAxisUnit;
                 std::shared_ptr<ArrayData<Dim> > m_ValuesData;
                 Unit m_ValuesUnit;
                 QReadWriteLock m_Lock;
             };
             #endif // SCIQLOP_DATASERIES_H

core/include/Data/DataSeriesIterator.h +6 0

             #ifndef SCIQLOP_DATASERIESITERATOR_H
             #define SCIQLOP_DATASERIESITERATOR_H
             #include "CoreGlobal.h"
             #include <memory>
             /**
              * @brief The DataSeriesIteratorValue class represents the current value of a data series iterator.
              * It offers standard access methods for the data in the series (x-axis, values), but it is up to
              * each series to define its own implementation of how to retrieve this data, by implementing the
              * DataSeriesIteratorValue::Impl interface
              *
              * @sa DataSeriesIterator
              */
             class SCIQLOP_CORE_EXPORT DataSeriesIteratorValue {
             public:
                 struct Impl {
                     virtual ~Impl() noexcept = default;
                     virtual std::unique_ptr<Impl> clone() const = 0;
                     virtual bool equals(const Impl &other) const = 0;
                     virtual void next() = 0;
                     virtual void prev() = 0;
                     virtual double x() const = 0;
                     virtual double value() const = 0;
                     virtual double value(int componentIndex) const = 0;
+                    virtual double minValue() const = 0;
+                    virtual double maxValue() const = 0;
                 };
                 explicit DataSeriesIteratorValue(std::unique_ptr<Impl> impl);
                 DataSeriesIteratorValue(const DataSeriesIteratorValue &other);
                 DataSeriesIteratorValue(DataSeriesIteratorValue &&other) = default;
                 DataSeriesIteratorValue &operator=(DataSeriesIteratorValue other);
                 bool equals(const DataSeriesIteratorValue &other) const;
                 /// Advances to the next value
                 void next();
                 /// Moves back to the previous value
                 void prev();
                 /// Gets x-axis data
                 double x() const;
                 /// Gets value data
                 double value() const;
                 /// Gets value data depending on an index
                 double value(int componentIndex) const;
+                /// Gets min of all values data
+                double minValue() const;
+                /// Gets max of all values data
+                double maxValue() const;
             private:
                 std::unique_ptr<Impl> m_Impl;
             };
             /**
              * @brief The DataSeriesIterator class represents an iterator used for data series. It defines all
              * operators needed for a standard forward iterator
              * @sa http://www.cplusplus.com/reference/iterator/
              */
             class SCIQLOP_CORE_EXPORT DataSeriesIterator {
             public:
                 using iterator_category = std::forward_iterator_tag;
                 using value_type = const DataSeriesIteratorValue;
                 using difference_type = std::ptrdiff_t;
                 using pointer = value_type *;
                 using reference = value_type &;
                 explicit DataSeriesIterator(DataSeriesIteratorValue value);
                 virtual ~DataSeriesIterator() noexcept = default;
                 DataSeriesIterator(const DataSeriesIterator &) = default;
                 DataSeriesIterator(DataSeriesIterator &&) = default;
                 DataSeriesIterator &operator=(const DataSeriesIterator &) = default;
                 DataSeriesIterator &operator=(DataSeriesIterator &&) = default;
                 DataSeriesIterator &operator++();
                 DataSeriesIterator &operator--();
                 pointer operator->() const { return &m_CurrentValue; }
                 reference operator*() const { return m_CurrentValue; }
                 bool operator==(const DataSeriesIterator &other) const;
                 bool operator!=(const DataSeriesIterator &other) const;
             private:
                 DataSeriesIteratorValue m_CurrentValue;
             };
             #endif // SCIQLOP_DATASERIESITERATOR_H

core/include/Data/IDataSeries.h +13 -5

             #ifndef SCIQLOP_IDATASERIES_H
             #define SCIQLOP_IDATASERIES_H
             #include <Common/MetaTypes.h>
             #include <Data/DataSeriesIterator.h>
             #include <Data/SqpRange.h>
             #include <memory>
             #include <QString>
             template <int Dim>
             class ArrayData;
             struct Unit {
                 explicit Unit(const QString &name = {}, bool timeUnit = false)
                         : m_Name{name}, m_TimeUnit{timeUnit}
                 {
                 }
                 inline bool operator==(const Unit &other) const
                 {
                     return std::tie(m_Name, m_TimeUnit) == std::tie(other.m_Name, other.m_TimeUnit);
                 }
                 inline bool operator!=(const Unit &other) const { return !(*this == other); }
                 QString m_Name;  ///< Unit name
                 bool m_TimeUnit; ///< The unit is a unit of time (UTC)
             };
             /**
              * @brief The IDataSeries aims to declare a data series.
              *
              * A data series is an entity that contains at least :
              * - one dataset representing the x-axis
              * - one dataset representing the values
              *
              * Each dataset is represented by an ArrayData, and is associated with a unit.
              *
              * An ArrayData can be unidimensional or two-dimensional, depending on the implementation of the
              * IDataSeries. The x-axis dataset is always unidimensional.
              *
              * @sa ArrayData
              */
             class IDataSeries {
             public:
                 virtual ~IDataSeries() noexcept = default;
                 /// Returns the x-axis dataset
                 virtual std::shared_ptr<ArrayData<1> > xAxisData() = 0;
                 /// Returns the x-axis dataset (as const)
                 virtual const std::shared_ptr<ArrayData<1> > xAxisData() const = 0;
                 virtual Unit xAxisUnit() const = 0;
                 virtual Unit valuesUnit() const = 0;
                 virtual void merge(IDataSeries *dataSeries) = 0;
                 /// @todo Review the name and signature of this method
                 virtual std::shared_ptr<IDataSeries> subDataSeries(const SqpRange &range) = 0;
                 virtual std::unique_ptr<IDataSeries> clone() const = 0;
                 virtual SqpRange range() const = 0;
                 // ///////// //
                 // Iterators //
                 // ///////// //
                 virtual DataSeriesIterator cbegin() const = 0;
                 virtual DataSeriesIterator cend() const = 0;
                 /// @return the iterator to the first entry of the data series whose x-axis data is greater than
                 /// or equal to the value passed in parameter, or the end iterator if there is no matching value
-                virtual DataSeriesIterator minData(double minXAxisData) const = 0;
+                virtual DataSeriesIterator minXAxisData(double minXAxisData) const = 0;
                 /// @return the iterator to the last entry of the data series whose x-axis data is less than or
                 /// equal to the value passed in parameter, or the end iterator if there is no matching value
-                virtual DataSeriesIterator maxData(double maxXAxisData) const = 0;
+                virtual DataSeriesIterator maxXAxisData(double maxXAxisData) const = 0;
-                virtual std::pair<DataSeriesIterator, DataSeriesIterator> subData(double min,
+                /// @return the iterators pointing to the range of data whose x-axis values are between min and
-                                                                                  double max) const = 0;
+                /// max passed in parameters
+                virtual std::pair<DataSeriesIterator, DataSeriesIterator>
+                xAxisRange(double minXAxisData, double maxXAxisData) const = 0;
+                /// @return two iterators pointing to the data that have respectively the min and the max value
+                /// data of a data series' range. The search is performed for a given x-axis range.
+                /// @sa xAxisRange()
+                virtual std::pair<DataSeriesIterator, DataSeriesIterator>
+                valuesBounds(double minXAxisData, double maxXAxisData) const = 0;
                 // /////// //
                 // Mutexes //
                 // /////// //
                 virtual void lockRead() = 0;
                 virtual void lockWrite() = 0;
                 virtual void unlock() = 0;
             };
             // Required for using shared_ptr in signals/slots
             SCIQLOP_REGISTER_META_TYPE(IDATASERIES_PTR_REGISTRY, std::shared_ptr<IDataSeries>)
             #endif // SCIQLOP_IDATASERIES_H

core/src/Data/DataSeriesIterator.cpp +10 0

             #include "Data/DataSeriesIterator.h"
             DataSeriesIteratorValue::DataSeriesIteratorValue(
                 std::unique_ptr<DataSeriesIteratorValue::Impl> impl)
                     : m_Impl{std::move(impl)}
             {
             }
             DataSeriesIteratorValue::DataSeriesIteratorValue(const DataSeriesIteratorValue &other)
                     : m_Impl{other.m_Impl->clone()}
             {
             }
             DataSeriesIteratorValue &DataSeriesIteratorValue::operator=(DataSeriesIteratorValue other)
             {
                 std::swap(m_Impl, other.m_Impl);
                 return *this;
             }
             bool DataSeriesIteratorValue::equals(const DataSeriesIteratorValue &other) const
             {
                 return m_Impl->equals(*other.m_Impl);
             }
             void DataSeriesIteratorValue::next()
             {
                 m_Impl->next();
             }
             void DataSeriesIteratorValue::prev()
             {
                 m_Impl->prev();
             }
             double DataSeriesIteratorValue::x() const
             {
                 return m_Impl->x();
             }
             double DataSeriesIteratorValue::value() const
             {
                 return m_Impl->value();
             }
             double DataSeriesIteratorValue::value(int componentIndex) const
             {
                 return m_Impl->value(componentIndex);
             }
+            double DataSeriesIteratorValue::minValue() const
+            {
+                return m_Impl->minValue();
+            }
+            double DataSeriesIteratorValue::maxValue() const
+            {
+                return m_Impl->maxValue();
+            }
             DataSeriesIterator::DataSeriesIterator(DataSeriesIteratorValue value)
                     : m_CurrentValue{std::move(value)}
             {
             }
             DataSeriesIterator &DataSeriesIterator::operator++()
             {
                 m_CurrentValue.next();
                 return *this;
             }
             DataSeriesIterator &DataSeriesIterator::operator--()
             {
                 m_CurrentValue.prev();
                 return *this;
             }
             bool DataSeriesIterator::operator==(const DataSeriesIterator &other) const
             {
                 return m_CurrentValue.equals(other.m_CurrentValue);
             }
             bool DataSeriesIterator::operator!=(const DataSeriesIterator &other) const
             {
                 return !(*this == other);
             }

core/src/Data/ScalarSeries.cpp +1 -1

             #include <Data/ScalarSeries.h>
             ScalarSeries::ScalarSeries(QVector<double> xAxisData, QVector<double> valuesData,
                                        const Unit &xAxisUnit, const Unit &valuesUnit)
                     : DataSeries{std::make_shared<ArrayData<1> >(std::move(xAxisData)), xAxisUnit,
                                  std::make_shared<ArrayData<1> >(std::move(valuesData)), valuesUnit}
             {
             }
             std::unique_ptr<IDataSeries> ScalarSeries::clone() const
             {
                 return std::make_unique<ScalarSeries>(*this);
             }
             std::shared_ptr<IDataSeries> ScalarSeries::subDataSeries(const SqpRange &range)
             {
                 auto subXAxisData = QVector<double>();
                 auto subValuesData = QVector<double>();
                 this->lockRead();
                 {
-                    auto bounds = subData(range.m_TStart, range.m_TEnd);
+                    auto bounds = xAxisRange(range.m_TStart, range.m_TEnd);
                     for (auto it = bounds.first; it != bounds.second; ++it) {
                         subXAxisData.append(it->x());
                         subValuesData.append(it->value());
                     }
                 }
                 this->unlock();
                 return std::make_shared<ScalarSeries>(subXAxisData, subValuesData, this->xAxisUnit(),
                                                       this->valuesUnit());
             }

core/src/Data/VectorSeries.cpp +1 -1

             #include "Data/VectorSeries.h"
             VectorSeries::VectorSeries(QVector<double> xAxisData, QVector<double> xValuesData,
                                        QVector<double> yValuesData, QVector<double> zValuesData,
                                        const Unit &xAxisUnit, const Unit &valuesUnit)
                     : DataSeries{std::make_shared<ArrayData<1> >(std::move(xAxisData)), xAxisUnit,
                                  std::make_shared<ArrayData<2> >(QVector<QVector<double> >{
                                      std::move(xValuesData), std::move(yValuesData), std::move(zValuesData)}),
                                  valuesUnit}
             {
             }
             std::unique_ptr<IDataSeries> VectorSeries::clone() const
             {
                 return std::make_unique<VectorSeries>(*this);
             }
             std::shared_ptr<IDataSeries> VectorSeries::subDataSeries(const SqpRange &range)
             {
                 auto subXAxisData = QVector<double>();
                 auto subXValuesData = QVector<double>();
                 auto subYValuesData = QVector<double>();
                 auto subZValuesData = QVector<double>();
                 this->lockRead();
                 {
-                    auto bounds = subData(range.m_TStart, range.m_TEnd);
+                    auto bounds = xAxisRange(range.m_TStart, range.m_TEnd);
                     for (auto it = bounds.first; it != bounds.second; ++it) {
                         subXAxisData.append(it->x());
                         subXValuesData.append(it->value(0));
                         subYValuesData.append(it->value(1));
                         subZValuesData.append(it->value(2));
                     }
                 }
                 this->unlock();
                 return std::make_shared<VectorSeries>(subXAxisData, subXValuesData, subYValuesData,
                                                       subZValuesData, this->xAxisUnit(), this->valuesUnit());
             }

core/src/Variable/VariableModel.cpp +2 -2

             #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
             #include <Common/DateUtils.h>
             #include <Data/IDataSeries.h>
             #include <QSize>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto TSTART_COLUMN = 1;
             const auto TEND_COLUMN = 2;
             const auto UNIT_COLUMN = 3;
             const auto MISSION_COLUMN = 4;
             const auto PLUGIN_COLUMN = 5;
             const auto NB_COLUMNS = 6;
             // Column properties
             const auto DEFAULT_HEIGHT = 25;
             const auto DEFAULT_WIDTH = 100;
             struct ColumnProperties {
                 ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
                                  int height = DEFAULT_HEIGHT)
                         : m_Name{name}, m_Width{width}, m_Height{height}
                 {
                 }
                 QString m_Name;
                 int m_Width;
                 int m_Height;
             };
             const auto COLUMN_PROPERTIES = QHash<int, ColumnProperties>{
                 {NAME_COLUMN, {QObject::tr("Name")}},       {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
                 {TEND_COLUMN, {QObject::tr("tEnd"), 180}},  {UNIT_COLUMN, {QObject::tr("Unit")}},
                 {MISSION_COLUMN, {QObject::tr("Mission")}}, {PLUGIN_COLUMN, {QObject::tr("Plugin")}}};
             /// Format for datetimes
             const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
             } // namespace
             struct VariableModel::VariableModelPrivate {
                 /// Variables created in SciQlop
                 std::vector<std::shared_ptr<Variable> > m_Variables;
                 std::unordered_map<std::shared_ptr<Variable>, double> m_VariableToProgress;
                 /// Return the row index of the variable. -1 if it's not found
                 int indexOfVariable(Variable *variable) const noexcept;
             };
             VariableModel::VariableModel(QObject *parent)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
             }
             std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
                                                                     const SqpRange &dateTime,
                                                                     const QVariantHash &metadata) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
                 auto variable = std::make_shared<Variable>(name, dateTime, metadata);
                 impl->m_Variables.push_back(variable);
                 connect(variable.get(), &Variable::updated, this, &VariableModel::onVariableUpdated);
                 endInsertRows();
                 return variable;
             }
             void VariableModel::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_Variable()) << "Can't delete a null variable from the model";
                     return;
                 }
                 // Finds variable in the model
                 auto begin = impl->m_Variables.cbegin();
                 auto end = impl->m_Variables.cend();
                 auto it = std::find(begin, end, variable);
                 if (it != end) {
                     auto removeIndex = std::distance(begin, it);
                     // Deletes variable
                     beginRemoveRows({}, removeIndex, removeIndex);
                     impl->m_Variables.erase(it);
                     endRemoveRows();
                 }
                 else {
                     qCritical(LOG_VariableModel())
                         << tr("Can't delete variable %1 from the model: the variable is not in the model")
                                .arg(variable->name());
                 }
                 // Removes variable from progress map
                 impl->m_VariableToProgress.erase(variable);
             }
             std::shared_ptr<Variable> VariableModel::variable(int index) const
             {
                 return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
             }
             void VariableModel::setDataProgress(std::shared_ptr<Variable> variable, double progress)
             {
                 if (progress > 0.0) {
                     impl->m_VariableToProgress[variable] = progress;
                 }
                 else {
                     impl->m_VariableToProgress.erase(variable);
                 }
                 auto modelIndex = createIndex(impl->indexOfVariable(variable.get()), NAME_COLUMN);
                 emit dataChanged(modelIndex, modelIndex);
             }
             int VariableModel::columnCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return NB_COLUMNS;
             }
             int VariableModel::rowCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return impl->m_Variables.size();
             }
             QVariant VariableModel::data(const QModelIndex &index, int role) const
             {
                 if (!index.isValid()) {
                     return QVariant{};
                 }
                 if (index.row() < 0 || index.row() >= rowCount()) {
                     return QVariant{};
                 }
                 if (role == Qt::DisplayRole) {
                     if (auto variable = impl->m_Variables.at(index.row()).get()) {
                         /// Lambda function that builds the variant to return for a time value
                         /// @param getValueFun function used to get for a data series the iterator on the entry
                         /// that contains the time value to display
                         auto dateTimeVariant = [variable](const auto &getValueFun) {
                             if (auto dataSeries = variable->dataSeries()) {
                                 auto it = getValueFun(*dataSeries);
                                 return (it != dataSeries->cend())
                                            ? DateUtils::dateTime(it->x()).toString(DATETIME_FORMAT)
                                            : QVariant{};
                             }
                             else {
                                 return QVariant{};
                             }
                         };
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case TSTART_COLUMN:
                                 // Shows the min value of the data series above the range tstart
                                 return dateTimeVariant([min = variable->range().m_TStart](
-                                    const auto &dataSeries) { return dataSeries.minData(min); });
+                                    const auto &dataSeries) { return dataSeries.minXAxisData(min); });
                             case TEND_COLUMN:
                                 // Shows the max value of the data series under the range tend
                                 return dateTimeVariant([max = variable->range().m_TEnd](
-                                    const auto &dataSeries) { return dataSeries.maxData(max); });
+                                    const auto &dataSeries) { return dataSeries.maxXAxisData(max); });
                             case UNIT_COLUMN:
                                 return variable->metadata().value(QStringLiteral("units"));
                             case MISSION_COLUMN:
                                 return variable->metadata().value(QStringLiteral("mission"));
                             case PLUGIN_COLUMN:
                                 return variable->metadata().value(QStringLiteral("plugin"));
                             default:
                                 // No action
                                 break;
                         }
                         qWarning(LOG_VariableModel())
                             << tr("Can't get data (unknown column %1)").arg(index.column());
                     }
                     else {
                         qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
                     }
                 }
                 else if (role == VariableRoles::ProgressRole) {
                     if (auto variable = impl->m_Variables.at(index.row())) {
                         auto it = impl->m_VariableToProgress.find(variable);
                         if (it != impl->m_VariableToProgress.cend()) {
                             return it->second;
                         }
                     }
                 }
                 return QVariant{};
             }
             QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
                     return QVariant{};
                 }
                 if (orientation == Qt::Horizontal) {
                     auto propertiesIt = COLUMN_PROPERTIES.find(section);
                     if (propertiesIt != COLUMN_PROPERTIES.cend()) {
                         // Role is either DisplayRole or SizeHintRole
                         return (role == Qt::DisplayRole)
                                    ? QVariant{propertiesIt->m_Name}
                                    : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
                     }
                     else {
                         qWarning(LOG_VariableModel())
                             << tr("Can't get header data (unknown column %1)").arg(section);
                     }
                 }
                 return QVariant{};
             }
             void VariableModel::abortProgress(const QModelIndex &index)
             {
                 if (auto variable = impl->m_Variables.at(index.row())) {
                     emit abortProgessRequested(variable);
                 }
             }
             void VariableModel::onVariableUpdated() noexcept
             {
                 // Finds variable that has been updated in the model
                 if (auto updatedVariable = dynamic_cast<Variable *>(sender())) {
                     auto updatedVariableIndex = impl->indexOfVariable(updatedVariable);
                     if (updatedVariableIndex > -1) {
                         emit dataChanged(createIndex(updatedVariableIndex, 0),
                                          createIndex(updatedVariableIndex, columnCount() - 1));
                     }
                 }
             }
             int VariableModel::VariableModelPrivate::indexOfVariable(Variable *variable) const noexcept
             {
                 auto begin = std::cbegin(m_Variables);
                 auto end = std::cend(m_Variables);
                 auto it
                     = std::find_if(begin, end, [variable](const auto &var) { return var.get() == variable; });
                 if (it != end) {
                     // Gets the index of the variable in the model: we assume here that views have the same
                     // order as the model
                     return std::distance(begin, it);
                 }
                 else {
                     return -1;
                 }
             }

core/tests/Data/TestDataSeries.cpp +230 -64

             #include "Data/DataSeries.h"
             #include "Data/ScalarSeries.h"
+            #include "Data/VectorSeries.h"
             #include <QObject>
             #include <QtTest>
             Q_DECLARE_METATYPE(std::shared_ptr<ScalarSeries>)
+            Q_DECLARE_METATYPE(std::shared_ptr<VectorSeries>)
             class TestDataSeries : public QObject {
                 Q_OBJECT
+            private:
+                template <typename T>
+                void testValuesBoundsStructure()
+                {
+                    // ////////////// //
+                    // Test structure //
+                    // ////////////// //
+                    // Data series to get values bounds
+                    QTest::addColumn<std::shared_ptr<T> >("dataSeries");
+                    // x-axis range
+                    QTest::addColumn<double>("minXAxis");
+                    QTest::addColumn<double>("maxXAxis");
+                    // Expected results
+                    QTest::addColumn<bool>(
+                        "expectedOK"); // Test is expected to be ok (i.e. method doesn't return end iterators)
+                    QTest::addColumn<double>("expectedMinValue");
+                    QTest::addColumn<double>("expectedMaxValue");
+                }
+                template <typename T>
+                void testValuesBounds()
+                {
+                    QFETCH(std::shared_ptr<T>, dataSeries);
+                    QFETCH(double, minXAxis);
+                    QFETCH(double, maxXAxis);
+                    QFETCH(bool, expectedOK);
+                    QFETCH(double, expectedMinValue);
+                    QFETCH(double, expectedMaxValue);
+                    auto minMaxIts = dataSeries->valuesBounds(minXAxis, maxXAxis);
+                    auto end = dataSeries->cend();
+                    // Checks iterators with expected result
+                    QCOMPARE(expectedOK, minMaxIts.first != end && minMaxIts.second != end);
+                    if (expectedOK) {
+                        auto compare = [](const auto &v1, const auto &v2) {
+                            return (std::isnan(v1) && std::isnan(v2)) || v1 == v2;
+                        };
+                        QVERIFY(compare(expectedMinValue, minMaxIts.first->minValue()));
+                        QVERIFY(compare(expectedMaxValue, minMaxIts.second->maxValue()));
+                    }
+                }
             private slots:
                 /// Input test data
                 /// @sa testCtor()
                 void testCtor_data();
                 /// Tests construction of a data series
                 void testCtor();
                 /// Input test data
                 /// @sa testMerge()
                 void testMerge_data();
                 /// Tests merge of two data series
                 void testMerge();
                 /// Input test data
-                /// @sa testMinData()
+                /// @sa testMinXAxisData()
-                void testMinData_data();
+                void testMinXAxisData_data();
+                /// Tests get min x-axis data of a data series
+                void testMinXAxisData();
+                /// Input test data
+                /// @sa testMaxXAxisData()
+                void testMaxXAxisData_data();
+                /// Tests get max x-axis data of a data series
+                void testMaxXAxisData();
+                /// Input test data
+                /// @sa testXAxisRange()
+                void testXAxisRange_data();
-                /// Tests get min data of a data series
+                /// Tests get x-axis range of a data series
-                void testMinData();
+                void testXAxisRange();
                 /// Input test data
-                /// @sa testMaxData()
+                /// @sa testValuesBoundsScalar()
-                void testMaxData_data();
+                void testValuesBoundsScalar_data();
-                /// Tests get max data of a data series
+                /// Tests get values bounds of a scalar series
-                void testMaxData();
+                void testValuesBoundsScalar();
                 /// Input test data
-                /// @sa testSubdata()
+                /// @sa testValuesBoundsVector()
-                void testSubdata_data();
+                void testValuesBoundsVector_data();
-                /// Tests get subdata of two data series
+                /// Tests get values bounds of a vector series
-                void testSubdata();
+                void testValuesBoundsVector();
             };
             void TestDataSeries::testCtor_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 // x-axis data
                 QTest::addColumn<QVector<double> >("xAxisData");
                 // values data
                 QTest::addColumn<QVector<double> >("valuesData");
                 // expected x-axis data
                 QTest::addColumn<QVector<double> >("expectedXAxisData");
                 // expected values data
                 QTest::addColumn<QVector<double> >("expectedValuesData");
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 QTest::newRow("invalidData (different sizes of vectors)")
                     << QVector<double>{1., 2., 3., 4., 5.} << QVector<double>{100., 200., 300.}
                     << QVector<double>{} << QVector<double>{};
                 QTest::newRow("sortedData") << QVector<double>{1., 2., 3., 4., 5.}
                                             << QVector<double>{100., 200., 300., 400., 500.}
                                             << QVector<double>{1., 2., 3., 4., 5.}
                                             << QVector<double>{100., 200., 300., 400., 500.};
                 QTest::newRow("unsortedData") << QVector<double>{5., 4., 3., 2., 1.}
                                               << QVector<double>{100., 200., 300., 400., 500.}
                                               << QVector<double>{1., 2., 3., 4., 5.}
                                               << QVector<double>{500., 400., 300., 200., 100.};
                 QTest::newRow("unsortedData2")
                     << QVector<double>{1., 4., 3., 5., 2.} << QVector<double>{100., 200., 300., 400., 500.}
                     << QVector<double>{1., 2., 3., 4., 5.} << QVector<double>{100., 500., 300., 200., 400.};
             }
             void TestDataSeries::testCtor()
             {
                 // Creates series
                 QFETCH(QVector<double>, xAxisData);
                 QFETCH(QVector<double>, valuesData);
                 auto series = std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                              Unit{}, Unit{});
                 // Validates results : we check that the data series is sorted on its x-axis data
                 QFETCH(QVector<double>, expectedXAxisData);
                 QFETCH(QVector<double>, expectedValuesData);
                 auto seriesXAxisData = series->xAxisData()->data();
                 auto seriesValuesData = series->valuesData()->data();
                 QVERIFY(
                     std::equal(expectedXAxisData.cbegin(), expectedXAxisData.cend(), seriesXAxisData.cbegin()));
                 QVERIFY(std::equal(expectedValuesData.cbegin(), expectedValuesData.cend(),
                                    seriesValuesData.cbegin()));
             }
             namespace {
-            std::shared_ptr<ScalarSeries> createSeries(QVector<double> xAxisData, QVector<double> valuesData)
+            std::shared_ptr<ScalarSeries> createScalarSeries(QVector<double> xAxisData,
+                                                             QVector<double> valuesData)
             {
                 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
                                                       Unit{});
             }
+            std::shared_ptr<VectorSeries> createVectorSeries(QVector<double> xAxisData,
+                                                             QVector<double> xValuesData,
+                                                             QVector<double> yValuesData,
+                                                             QVector<double> zValuesData)
+            {
+                return std::make_shared<VectorSeries>(std::move(xAxisData), std::move(xValuesData),
+                                                      std::move(yValuesData), std::move(zValuesData), Unit{},
+                                                      Unit{});
+            }
             } // namespace
             void TestDataSeries::testMerge_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 // Data series to merge
                 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
                 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries2");
                 // Expected values in the first data series after merge
                 QTest::addColumn<QVector<double> >("expectedXAxisData");
                 QTest::addColumn<QVector<double> >("expectedValuesData");
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 QTest::newRow("sortedMerge")
-                    << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                    << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
-                    << createSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
+                    << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
                     << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
                     << QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
                 QTest::newRow("unsortedMerge")
-                    << createSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
+                    << createScalarSeries({6., 7., 8., 9., 10.}, {600., 700., 800., 900., 1000.})
-                    << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                    << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
                     << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
                     << QVector<double>{100., 200., 300., 400., 500., 600., 700., 800., 900., 1000.};
                 QTest::newRow("unsortedMerge2")
-                    << createSeries({1., 2., 8., 9., 10}, {100., 200., 300., 400., 500.})
+                    << createScalarSeries({1., 2., 8., 9., 10}, {100., 200., 300., 400., 500.})
-                    << createSeries({3., 4., 5., 6., 7.}, {600., 700., 800., 900., 1000.})
+                    << createScalarSeries({3., 4., 5., 6., 7.}, {600., 700., 800., 900., 1000.})
                     << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
                     << QVector<double>{100., 200., 600., 700., 800., 900., 1000., 300., 400., 500.};
                 QTest::newRow("unsortedMerge3")
-                    << createSeries({3., 5., 8., 7., 2}, {100., 200., 300., 400., 500.})
+                    << createScalarSeries({3., 5., 8., 7., 2}, {100., 200., 300., 400., 500.})
-                    << createSeries({6., 4., 9., 10., 1.}, {600., 700., 800., 900., 1000.})
+                    << createScalarSeries({6., 4., 9., 10., 1.}, {600., 700., 800., 900., 1000.})
                     << QVector<double>{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.}
                     << QVector<double>{1000., 500., 100., 700., 200., 600., 400., 300., 800., 900.};
             }
             void TestDataSeries::testMerge()
             {
                 // Merges series
                 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
                 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries2);
                 dataSeries->merge(dataSeries2.get());
                 // Validates results : we check that the merge is valid and the data series is sorted on its
                 // x-axis data
                 QFETCH(QVector<double>, expectedXAxisData);
                 QFETCH(QVector<double>, expectedValuesData);
                 auto seriesXAxisData = dataSeries->xAxisData()->data();
                 auto seriesValuesData = dataSeries->valuesData()->data();
                 QVERIFY(
                     std::equal(expectedXAxisData.cbegin(), expectedXAxisData.cend(), seriesXAxisData.cbegin()));
                 QVERIFY(std::equal(expectedValuesData.cbegin(), expectedValuesData.cend(),
                                    seriesValuesData.cbegin()));
             }
-            void TestDataSeries::testMinData_data()
+            void TestDataSeries::testMinXAxisData_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 // Data series to get min data
                 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
                 // Min data
                 QTest::addColumn<double>("min");
                 // Expected results
                 QTest::addColumn<bool>(
                     "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
                 QTest::addColumn<double>(
                     "expectedMin"); // Expected value when method doesn't return end iterator
                 // ////////// //
                 // Test cases //
                 // ////////// //
-                QTest::newRow("minData1") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                QTest::newRow("minData1") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                                {100., 200., 300., 400., 500.})
                                           << 0. << true << 1.;
-                QTest::newRow("minData2") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                QTest::newRow("minData2") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                                {100., 200., 300., 400., 500.})
                                           << 1. << true << 1.;
-                QTest::newRow("minData3") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                QTest::newRow("minData3") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                                {100., 200., 300., 400., 500.})
                                           << 1.1 << true << 2.;
-                QTest::newRow("minData4") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                QTest::newRow("minData4") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                                {100., 200., 300., 400., 500.})
                                           << 5. << true << 5.;
-                QTest::newRow("minData5") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                QTest::newRow("minData5") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                                {100., 200., 300., 400., 500.})
                                           << 5.1 << false << std::numeric_limits<double>::quiet_NaN();
-                QTest::newRow("minData6") << createSeries({}, {}) << 1.1 << false
+                QTest::newRow("minData6") << createScalarSeries({}, {}) << 1.1 << false
                                           << std::numeric_limits<double>::quiet_NaN();
             }
-            void TestDataSeries::testMinData()
+            void TestDataSeries::testMinXAxisData()
             {
                 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
                 QFETCH(double, min);
                 QFETCH(bool, expectedOK);
                 QFETCH(double, expectedMin);
-                auto it = dataSeries->minData(min);
+                auto it = dataSeries->minXAxisData(min);
                 QCOMPARE(expectedOK, it != dataSeries->cend());
                 // If the method doesn't return a end iterator, checks with expected value
                 if (expectedOK) {
                     QCOMPARE(expectedMin, it->x());
                 }
             }
-            void TestDataSeries::testMaxData_data()
+            void TestDataSeries::testMaxXAxisData_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
                 // Data series to get max data
                 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
                 // Max data
                 QTest::addColumn<double>("max");
                 // Expected results
                 QTest::addColumn<bool>(
                     "expectedOK"); // if true, expects to have a result (i.e. the iterator != end iterator)
                 QTest::addColumn<double>(
                     "expectedMax"); // Expected value when method doesn't return end iterator
                 // ////////// //
                 // Test cases //
                 // ////////// //
-                QTest::newRow("maxData1") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                QTest::newRow("maxData1") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                                {100., 200., 300., 400., 500.})
                                           << 6. << true << 5.;
-                QTest::newRow("maxData2") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                QTest::newRow("maxData2") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                                {100., 200., 300., 400., 500.})
                                           << 5. << true << 5.;
-                QTest::newRow("maxData3") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                QTest::newRow("maxData3") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                                {100., 200., 300., 400., 500.})
                                           << 4.9 << true << 4.;
-                QTest::newRow("maxData4") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                QTest::newRow("maxData4") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                                {100., 200., 300., 400., 500.})
                                           << 1.1 << true << 1.;
-                QTest::newRow("maxData5") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                QTest::newRow("maxData5") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                                {100., 200., 300., 400., 500.})
                                           << 1. << true << 1.;
-                QTest::newRow("maxData6") << createSeries({}, {}) << 1.1 << false
+                QTest::newRow("maxData6") << createScalarSeries({}, {}) << 1.1 << false
                                           << std::numeric_limits<double>::quiet_NaN();
             }
-            void TestDataSeries::testMaxData()
+            void TestDataSeries::testMaxXAxisData()
             {
                 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
                 QFETCH(double, max);
                 QFETCH(bool, expectedOK);
                 QFETCH(double, expectedMax);
-                auto it = dataSeries->maxData(max);
+                auto it = dataSeries->maxXAxisData(max);
                 QCOMPARE(expectedOK, it != dataSeries->cend());
                 // If the method doesn't return a end iterator, checks with expected value
                 if (expectedOK) {
                     QCOMPARE(expectedMax, it->x());
                 }
             }
-            void TestDataSeries::testSubdata_data()
+            void TestDataSeries::testXAxisRange_data()
             {
                 // ////////////// //
                 // Test structure //
                 // ////////////// //
-                // Data series to get subdata
+                // Data series to get x-axis range
                 QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");
                 // Min/max values
                 QTest::addColumn<double>("min");
                 QTest::addColumn<double>("max");
-                // Expected values after subdata
+                // Expected values
                 QTest::addColumn<QVector<double> >("expectedXAxisData");
                 QTest::addColumn<QVector<double> >("expectedValuesData");
                 // ////////// //
                 // Test cases //
                 // ////////// //
-                QTest::newRow("subData1") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                QTest::newRow("xAxisRange1") << createScalarSeries({1., 2., 3., 4., 5.},
-                                          << -1. << 3.2 << QVector<double>{1., 2., 3.}
+                                                                   {100., 200., 300., 400., 500.})
-                                          << QVector<double>{100., 200., 300.};
+                                             << -1. << 3.2 << QVector<double>{1., 2., 3.}
-                QTest::newRow("subData2") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                                             << QVector<double>{100., 200., 300.};
-                                          << 1. << 4. << QVector<double>{1., 2., 3., 4.}
+                QTest::newRow("xAxisRange2") << createScalarSeries({1., 2., 3., 4., 5.},
-                                          << QVector<double>{100., 200., 300., 400.};
+                                                                   {100., 200., 300., 400., 500.})
-                QTest::newRow("subData3") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                                             << 1. << 4. << QVector<double>{1., 2., 3., 4.}
-                                          << 1. << 3.9 << QVector<double>{1., 2., 3.}
+                                             << QVector<double>{100., 200., 300., 400.};
-                                          << QVector<double>{100., 200., 300.};
+                QTest::newRow("xAxisRange3") << createScalarSeries({1., 2., 3., 4., 5.},
-                QTest::newRow("subData4") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                                                                   {100., 200., 300., 400., 500.})
-                                          << 0. << 0.9 << QVector<double>{} << QVector<double>{};
+                                             << 1. << 3.9 << QVector<double>{1., 2., 3.}
-                QTest::newRow("subData5") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                                             << QVector<double>{100., 200., 300.};
-                                          << 0. << 1. << QVector<double>{1.} << QVector<double>{100.};
+                QTest::newRow("xAxisRange4") << createScalarSeries({1., 2., 3., 4., 5.},
-                QTest::newRow("subData6") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                                                                   {100., 200., 300., 400., 500.})
-                                          << 2.1 << 6. << QVector<double>{3., 4., 5.}
+                                             << 0. << 0.9 << QVector<double>{} << QVector<double>{};
-                                          << QVector<double>{300., 400., 500.};
+                QTest::newRow("xAxisRange5") << createScalarSeries({1., 2., 3., 4., 5.},
-                QTest::newRow("subData7") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                                                                   {100., 200., 300., 400., 500.})
-                                          << 6. << 9. << QVector<double>{} << QVector<double>{};
+                                             << 0. << 1. << QVector<double>{1.} << QVector<double>{100.};
-                QTest::newRow("subData8") << createSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.})
+                QTest::newRow("xAxisRange6") << createScalarSeries({1., 2., 3., 4., 5.},
-                                          << 5. << 9. << QVector<double>{5.} << QVector<double>{500.};
+                                                                   {100., 200., 300., 400., 500.})
+                                             << 2.1 << 6. << QVector<double>{3., 4., 5.}
+                                             << QVector<double>{300., 400., 500.};
+                QTest::newRow("xAxisRange7") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                                   {100., 200., 300., 400., 500.})
+                                             << 6. << 9. << QVector<double>{} << QVector<double>{};
+                QTest::newRow("xAxisRange8") << createScalarSeries({1., 2., 3., 4., 5.},
+                                                                   {100., 200., 300., 400., 500.})
+                                             << 5. << 9. << QVector<double>{5.} << QVector<double>{500.};
             }
-            void TestDataSeries::testSubdata()
+            void TestDataSeries::testXAxisRange()
             {
                 QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);
                 QFETCH(double, min);
                 QFETCH(double, max);
                 QFETCH(QVector<double>, expectedXAxisData);
                 QFETCH(QVector<double>, expectedValuesData);
-                auto bounds = dataSeries->subData(min, max);
+                auto bounds = dataSeries->xAxisRange(min, max);
                 QVERIFY(std::equal(bounds.first, bounds.second, expectedXAxisData.cbegin(),
                                    expectedXAxisData.cend(),
                                    [](const auto &it, const auto &expectedX) { return it.x() == expectedX; }));
                 QVERIFY(std::equal(
                     bounds.first, bounds.second, expectedValuesData.cbegin(), expectedValuesData.cend(),
                     [](const auto &it, const auto &expectedVal) { return it.value() == expectedVal; }));
             }
+            void TestDataSeries::testValuesBoundsScalar_data()
+            {
+                testValuesBoundsStructure<ScalarSeries>();
+                // ////////// //
+                // Test cases //
+                // ////////// //
+                auto nan = std::numeric_limits<double>::quiet_NaN();
+                QTest::newRow("scalarBounds1")
+                    << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 6.
+                    << true << 100. << 500.;
+                QTest::newRow("scalarBounds2")
+                    << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 2. << 4.
+                    << true << 200. << 400.;
+                QTest::newRow("scalarBounds3")
+                    << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 0. << 0.5
+                    << false << nan << nan;
+                QTest::newRow("scalarBounds4")
+                    << createScalarSeries({1., 2., 3., 4., 5.}, {100., 200., 300., 400., 500.}) << 5.1 << 6.
+                    << false << nan << nan;
+                QTest::newRow("scalarBounds5")
+                    << createScalarSeries({1.}, {100.}) << 0. << 2. << true << 100. << 100.;
+                QTest::newRow("scalarBounds6") << createScalarSeries({}, {}) << 0. << 2. << false << nan << nan;
+                // Tests with NaN values: NaN values are not included in min/max search
+                QTest::newRow("scalarBounds7")
+                    << createScalarSeries({1., 2., 3., 4., 5.}, {nan, 200., 300., 400., nan}) << 0. << 6.
+                    << true << 200. << 400.;
+                QTest::newRow("scalarBounds8")
+                    << createScalarSeries({1., 2., 3., 4., 5.}, {nan, nan, nan, nan, nan}) << 0. << 6. << true
+                    << std::numeric_limits<double>::quiet_NaN() << std::numeric_limits<double>::quiet_NaN();
+            }
+            void TestDataSeries::testValuesBoundsScalar()
+            {
+                testValuesBounds<ScalarSeries>();
+            }
+            void TestDataSeries::testValuesBoundsVector_data()
+            {
+                testValuesBoundsStructure<VectorSeries>();
+                // ////////// //
+                // Test cases //
+                // ////////// //
+                auto nan = std::numeric_limits<double>::quiet_NaN();
+                QTest::newRow("vectorBounds1")
+                    << createVectorSeries({1., 2., 3., 4., 5.}, {10., 15., 20., 13., 12.},
+                                          {35., 24., 10., 9., 0.3}, {13., 14., 12., 9., 24.})
+                    << 0. << 6. << true << 0.3 << 35.; // min/max in same component
+                QTest::newRow("vectorBounds2")
+                    << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
+                                          {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
+                    << 0. << 6. << true << 2.3 << 35.; // min/max in same entry
+                QTest::newRow("vectorBounds3")
+                    << createVectorSeries({1., 2., 3., 4., 5.}, {2.3, 15., 20., 13., 12.},
+                                          {35., 24., 10., 9., 4.}, {13., 14., 12., 9., 24.})
+                    << 2. << 3. << true << 10. << 24.;
+                // Tests with NaN values: NaN values are not included in min/max search
+                QTest::newRow("vectorBounds4")
+                    << createVectorSeries({1., 2.}, {nan, nan}, {nan, nan}, {nan, nan}) << 0. << 6. << true
+                    << nan << nan;
+            }
+            void TestDataSeries::testValuesBoundsVector()
+            {
+                testValuesBounds<VectorSeries>();
+            }
             QTEST_MAIN(TestDataSeries)
             #include "TestDataSeries.moc"

gui/src/Visualization/VisualizationGraphHelper.cpp +1 -1

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Common/ColorUtils.h>
             #include <Data/ScalarSeries.h>
             #include <Data/VectorSeries.h>
             #include <Variable/Variable.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphHelper, "VisualizationGraphHelper")
             namespace {
             class SqpDataContainer : public QCPGraphDataContainer {
             public:
                 void appendGraphData(const QCPGraphData &data) { mData.append(data); }
             };
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
             /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
             /// non-time data
             QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
             {
                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
                     dateTicker->setDateTimeSpec(Qt::UTC);
                     return dateTicker;
                 }
                 else {
                     // default ticker
                     return QSharedPointer<QCPAxisTicker>::create();
                 }
             }
             /// Sets axes properties according to the properties of a data series
             template <int Dim>
             void setAxesProperties(const DataSeries<Dim> &dataSeries, QCustomPlot &plot) noexcept
             {
                 /// @todo : for the moment, no control is performed on the axes: the units and the tickers
                 /// are fixed for the default x-axis and y-axis of the plot, and according to the new graph
                 auto setAxisProperties = [](auto axis, const auto &unit) {
                     // label (unit name)
                     axis->setLabel(unit.m_Name);
                     // ticker (depending on the type of unit)
                     axis->setTicker(axisTicker(unit.m_TimeUnit));
                 };
                 setAxisProperties(plot.xAxis, dataSeries.xAxisUnit());
                 setAxisProperties(plot.yAxis, dataSeries.valuesUnit());
             }
             /**
              * Struct used to create plottables, depending on the type of the data series from which to create
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't create plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesCreator {
                 static PlottablesMap createPlottables(T &, QCustomPlot &)
                 {
                     qCCritical(LOG_DataSeries())
                         << QObject::tr("Can't create plottables: unmanaged data series type");
                     return {};
                 }
             };
             /**
              * Specialization of PlottablesCreator for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesCreator<T,
                                      typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                                or std::is_base_of<VectorSeries, T>::value> > {
                 static PlottablesMap createPlottables(T &dataSeries, QCustomPlot &plot)
                 {
                     PlottablesMap result{};
                     // Gets the number of components of the data series
                     auto componentCount = dataSeries.valuesData()->componentCount();
                     auto colors = ColorUtils::colors(Qt::blue, Qt::red, componentCount);
                     // For each component of the data series, creates a QCPGraph to add to the plot
                     for (auto i = 0; i < componentCount; ++i) {
                         auto graph = plot.addGraph();
                         graph->setPen(QPen{colors.at(i)});
                         result.insert({i, graph});
                     }
                     // Axes properties
                     setAxesProperties(dataSeries, plot);
                     plot.replot();
                     return result;
                 }
             };
             /**
              * Struct used to update plottables, depending on the type of the data series from which to update
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't update plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesUpdater {
                 static void updatePlottables(T &, PlottablesMap &, const SqpRange &, bool)
                 {
                     qCCritical(LOG_DataSeries())
                         << QObject::tr("Can't update plottables: unmanaged data series type");
                 }
             };
             /**
              * Specialization of PlottablesUpdater for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesUpdater<T,
                                      typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                                or std::is_base_of<VectorSeries, T>::value> > {
                 static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const SqpRange &range,
                                              bool rescaleAxes)
                 {
                     dataSeries.lockRead();
                     // For each plottable to update, resets its data
                     std::map<int, QSharedPointer<SqpDataContainer> > dataContainers{};
                     for (const auto &plottable : plottables) {
                         if (auto graph = dynamic_cast<QCPGraph *>(plottable.second)) {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             graph->setData(dataContainer);
                             dataContainers.insert({plottable.first, dataContainer});
                         }
                     }
                     // - Gets the data of the series included in the current range
                     // - Updates each plottable by adding, for each data item, a point that takes x-axis data
                     // and value data. The correct value is retrieved according to the index of the component
-                    auto subDataIts = dataSeries.subData(range.m_TStart, range.m_TEnd);
+                    auto subDataIts = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);
                     for (auto it = subDataIts.first; it != subDataIts.second; ++it) {
                         for (const auto &dataContainer : dataContainers) {
                             auto componentIndex = dataContainer.first;
                             dataContainer.second->appendGraphData(
                                 QCPGraphData(it->x(), it->value(componentIndex)));
                         }
                     }
                     dataSeries.unlock();
                     if (!plottables.empty()) {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes) {
                             plot->rescaleAxes();
                         }
                         plot->replot();
                     }
                 }
             };
             /**
              * Helper used to create/update plottables
              */
             struct IPlottablesHelper {
                 virtual ~IPlottablesHelper() noexcept = default;
                 virtual PlottablesMap create(QCustomPlot &plot) const = 0;
                 virtual void update(PlottablesMap &plottables, const SqpRange &range,
                                     bool rescaleAxes = false) const = 0;
             };
             /**
              * Default implementation of IPlottablesHelper, which takes data series to create/update plottables
              * @tparam T the data series' type
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper {
                 explicit PlottablesHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
                 PlottablesMap create(QCustomPlot &plot) const override
                 {
                     return PlottablesCreator<T>::createPlottables(m_DataSeries, plot);
                 }
                 void update(PlottablesMap &plottables, const SqpRange &range, bool rescaleAxes) const override
                 {
                     PlottablesUpdater<T>::updatePlottables(m_DataSeries, plottables, range, rescaleAxes);
                 }
                 T &m_DataSeries;
             };
             /// Creates IPlottablesHelper according to a data series
             std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
                     return std::make_unique<PlottablesHelper<ScalarSeries> >(*scalarSeries);
                 }
                 else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
                     return std::make_unique<PlottablesHelper<VectorSeries> >(*vectorSeries);
                 }
                 else {
                     return std::make_unique<PlottablesHelper<IDataSeries> >(*dataSeries);
                 }
             }
             } // namespace
             PlottablesMap VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
                                                            QCustomPlot &plot) noexcept
             {
                 if (variable) {
                     auto helper = createHelper(variable->dataSeries());
                     auto plottables = helper->create(plot);
                     return plottables;
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                     return PlottablesMap{};
                 }
             }
             void VisualizationGraphHelper::updateData(PlottablesMap &plottables,
                                                       std::shared_ptr<IDataSeries> dataSeries,
                                                       const SqpRange &dateTime)
             {
                 auto helper = createHelper(dataSeries);
                 helper->update(plottables, dateTime);
             }

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