GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1040:bcdcc2f6c21f

Fixes compilation

Alexandre Leroux -

r1040:bcdcc2f6c21f

parent child

Context file:

r1040:bcdcc2f6c21f

Collapse all files

core/include/Data/DataSeriesUtils.h +1 0

             #ifndef SCIQLOP_DATASERIESUTILS_H
             #define SCIQLOP_DATASERIESUTILS_H
             #include "CoreGlobal.h"
             #include <Data/DataSeriesIterator.h>
+            #include <cmath>
             #include <QLoggingCategory>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSeriesUtils)
             /**
              * Utility class with methods for data series
              */
             struct SCIQLOP_CORE_EXPORT DataSeriesUtils {
                 /**
                  * Define a meshs.
                  *
                  * A mesh is a regular grid representing cells of the same width (in x) and of the same height
                  * (in y). At each mesh point is associated a value.
                  *
                  * Each axis of the mesh is defined by a minimum value, a number of values is a mesh step.
                  * For example: if min = 1, nbValues = 5 and step = 2 => the axis of the mesh will be [1, 3, 5,
                  * 7, 9].
                  *
                  * The values are defined in an array of size {nbX * nbY}. The data is stored along the X axis.
                  *
                  * For example, the mesh:
                  * Y = 2 [  7   ;   8   ;   9
                  * Y = 1    4   ;   5   ;   6
                  * Y = 0    1   ;   2   ;   3   ]
                  *        X = 0   X = 1   X = 2
                  *
                  * will be represented by data [1, 2, 3, 4, 5, 6, 7, 8, 9]
                  */
                 struct Mesh {
                     explicit Mesh() = default;
                     explicit Mesh(int nbX, double xMin, double xStep, int nbY, double yMin, double yStep)
                             : m_NbX{nbX},
                               m_XMin{xMin},
                               m_XStep{xStep},
                               m_NbY{nbY},
                               m_YMin{yMin},
                               m_YStep{yStep},
                               m_Data(nbX * nbY)
                     {
                     }
                     inline bool isEmpty() const { return m_Data.size() == 0; }
                     inline double xMax() const { return m_XMin + (m_NbX - 1) * m_XStep; }
                     inline double yMax() const { return m_YMin + (m_NbY - 1) * m_YStep; }
                     int m_NbX{0};
                     double m_XMin{};
                     double m_XStep{};
                     int m_NbY{0};
                     double m_YMin{};
                     double m_YStep{};
                     std::vector<double> m_Data{};
                 };
                 /**
                  * Represents a resolution used to generate the data of a mesh on the x-axis or in Y.
                  *
                  * A resolution is represented by a value and flag indicating if it's in the logarithmic scale
                  * @sa Mesh
                  */
                 struct Resolution {
                     double m_Val{std::numeric_limits<double>::quiet_NaN()};
                     bool m_Logarithmic{false};
                 };
                 /**
                  * Processes data from a data series to complete the data holes with a fill value.
                  *
                  * A data hole is determined by the resolution passed in parameter: if, between two continuous
                  * data on the x-axis, the difference between these data is greater than the resolution, then
                  * there is one or more holes between them. The holes are filled by adding:
                  * - for the x-axis, new data corresponding to the 'step resolution' starting from the first
                  * data;
                  * - for values, a default value (fill value) for each new data added on the x-axis.
                  *
                  * For example, with :
                  * - xAxisData =  [0,    1,    5,    7,    14  ]
                  * - valuesData = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] (two components per x-axis data)
                  * - fillValue = NaN
                  * - and resolution = 2;
                  *
                  * For the x axis, we calculate as data holes: [3, 9, 11, 13]. These holes are added to the
                  * x-axis data, and NaNs (two per x-axis data) are added to the values:
                  * => xAxisData =  [0,    1,    3,        5,    7,    9,        11,       13,       14  ]
                  * => valuesData = [0, 1, 2, 3, NaN, NaN, 4, 5, 6, 7, NaN, NaN, NaN, NaN, NaN, NaN, 8, 9]
                  *
                  * It is also possible to set bounds for the data series. If these bounds are defined and exceed
                  * the limits of the data series, data holes are added to the series at the beginning and/or the
                  * end.
                  *
                  * The generation of data holes at the beginning/end of the data series is performed starting
                  * from the x-axis series limit and adding data holes at each 'resolution step' as long as the
                  * new bound is not reached.
                  *
                  * For example, with :
                  * - xAxisData =  [3,    4,    5,    6,    7  ]
                  * - valuesData = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
                  * - fillValue = NaN
                  * - minBound = 0
                  * - maxBound = 12
                  * - and resolution = 2;
                  *
                  * => Starting from 3 and decreasing 2 by 2 until reaching 0 : a data hole at value 1 will be
                  * added to the beginning of the series
                  * => Starting from 7 and increasing 2 by 2 until reaching 12 : data holes at values 9 and 11
                  * will be added to the end of the series
                  *
                  * So :
                  * => xAxisData =  [1,        3,    4,    5,    6,    7,    9,        11      ]
                  * => valuesData = [NaN, NaN, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, NaN, NaN, NaN, NaN]
                  *
                  * @param xAxisData the x-axis data of the data series
                  * @param valuesData the values data of the data series
                  * @param resolution the resoultion (on x-axis) used to determinate data holes
                  * @param fillValue the fill value used for data holes in the values data
                  * @param minBound the limit at which to start filling data holes for the series. If set to NaN,
                  * the limit is not used
                  * @param maxBound the limit at which to end filling data holes for the series. If set to NaN,
                  * the limit is not used
                  *
                  * @remarks There is no control over the consistency between x-axis data and values data. The
                  * method considers that the data is well formed (the total number of values data is a multiple
                  * of the number of x-axis data)
                  */
                 static void fillDataHoles(std::vector<double> &xAxisData, std::vector<double> &valuesData,
                                           double resolution,
                                           double fillValue = std::numeric_limits<double>::quiet_NaN(),
                                           double minBound = std::numeric_limits<double>::quiet_NaN(),
                                           double maxBound = std::numeric_limits<double>::quiet_NaN());
                 /**
                  * Computes the resolution of a dataset passed as a parameter.
                  *
                  * The resolution of a dataset is the minimum difference between two values that follow in the
                  * set.
                  * For example:
                  * - for the set [0, 2, 4, 8, 10, 11, 13] => the resolution is 1 (difference between 10 and 11).
                  *
                  * A resolution can be calculated on the logarithmic scale (base of 10). In this case, the
                  * dataset is first converted to logarithmic values.
                  * For example:
                  * - for the set [10, 100, 10000, 1000000], the values are converted to [1, 2, 4, 6] => the
                  * logarithmic resolution is 1 (difference between 1 and 2).
                  *
                  * @param begin the iterator pointing to the beginning of the dataset
                  * @param end the iterator pointing to the end of the dataset
                  * @param logarithmic computes a logarithmic resolution or not
                  * @return the resolution computed
                  * @warning the method considers the dataset as sorted and doesn't control it.
                  */
                 template <typename Iterator>
                 static Resolution resolution(Iterator begin, Iterator end, bool logarithmic = false);
                 /**
                  * Computes a regular mesh for a data series, according to resolutions for x-axis and y-axis
                  * passed as parameters.
                  *
                  * The mesh is created from the resolutions in x and y and the boundaries delimiting the data
                  * series. If the resolutions do not allow to obtain a regular mesh, they are recalculated.
                  *
                  * For example :
                  * Let x-axis data = [0, 1, 3, 5, 9], its associated values = [0, 10, 30, 50, 90] and
                  * xResolution = 2.
                  * Based on the resolution, the mesh would be [0, 2, 4, 6, 8, 10] and would be invalid because
                  * it exceeds the maximum bound of the data. The resolution is thus recalculated so that the
                  * mesh holds between the data terminals.
                  * So => resolution is 1.8 and the mesh is [0, 1.8, 3.6, 5.4, 7.2, 9].
                  *
                  * Once the mesh is generated in x and y, the values are associated with each mesh point,
                  * based on the data in the series, finding the existing data at which the mesh point would be
                  * or would be closest to, without exceeding it.
                  *
                  * In the example, we determine the value of each mesh point:
                  * - x = 0 => value = 0 (existing x in the data series)
                  * - x = 1.8 => value = 10 (the closest existing x: 1)
                  * - x = 3.6 => value = 30 (the closest existing x: 3)
                  * - x = 5.4 => value = 50 (the closest existing x: 5)
                  * - x = 7.2 => value = 50 (the closest existing x: 5)
                  * - x = 9 => value = 90 (existing x in the data series)
                  *
                  * Same algorithm is applied for y-axis.
                  *
                  * @param begin the iterator pointing to the beginning of the data series
                  * @param end the iterator pointing to the end of the data series
                  * @param xResolution the resolution expected for the mesh's x-axis
                  * @param yResolution the resolution expected for the mesh's y-axis
                  * @return the mesh created, an empty mesh if the input data do not allow to generate a regular
                  * mesh (empty data, null resolutions, logarithmic x-axis)
                  * @warning the method considers the dataset as sorted and doesn't control it.
                  */
                 static Mesh regularMesh(DataSeriesIterator begin, DataSeriesIterator end,
                                         Resolution xResolution, Resolution yResolution);
             };
             template <typename Iterator>
             DataSeriesUtils::Resolution DataSeriesUtils::resolution(Iterator begin, Iterator end,
                                                                     bool logarithmic)
             {
                 // Retrieves data into a work dataset
                 using ValueType = typename Iterator::value_type;
                 std::vector<ValueType> values{};
                 std::copy(begin, end, std::back_inserter(values));
                 // Converts data if logarithmic flag is activated
                 if (logarithmic) {
                     std::for_each(values.begin(), values.end(),
                                   [logarithmic](auto &val) { val = std::log10(val); });
                 }
                 // Computes the differences between the values in the dataset
                 std::adjacent_difference(values.begin(), values.end(), values.begin());
                 // Retrieves the smallest difference
                 auto resolutionIt = std::min_element(values.begin(), values.end());
                 auto resolution
                     = resolutionIt != values.end() ? *resolutionIt : std::numeric_limits<double>::quiet_NaN();
                 return Resolution{resolution, logarithmic};
             }
             #endif // SCIQLOP_DATASERIESUTILS_H

core/src/Data/DataSeriesUtils.cpp 0 -2

             #include "Data/DataSeriesUtils.h"
-            #include <cmath>
             Q_LOGGING_CATEGORY(LOG_DataSeriesUtils, "DataSeriesUtils")
             void DataSeriesUtils::fillDataHoles(std::vector<double> &xAxisData, std::vector<double> &valuesData,
                                                 double resolution, double fillValue, double minBound,
                                                 double maxBound)
             {
                 if (resolution == 0. || std::isnan(resolution)) {
                     qCWarning(LOG_DataSeriesUtils())
                         << "Can't fill data holes with a null resolution, no changes will be made";
                     return;
                 }
                 if (xAxisData.empty()) {
                     qCWarning(LOG_DataSeriesUtils())
                         << "Can't fill data holes for empty data, no changes will be made";
                     return;
                 }
                 // Gets the number of values per x-axis data
                 auto nbComponents = valuesData.size() / xAxisData.size();
                 // Generates fill values that will be used to complete values data
                 std::vector<double> fillValues(nbComponents, fillValue);
                 // Checks if there are data holes on the beginning of the data and generates the hole at the
                 // extremity if it's the case
                 auto minXAxisData = xAxisData.front();
                 if (!std::isnan(minBound) && minBound < minXAxisData) {
                     auto holeSize = static_cast<int>((minXAxisData - minBound) / resolution);
                     if (holeSize > 0) {
                         xAxisData.insert(xAxisData.begin(), minXAxisData - holeSize * resolution);
                         valuesData.insert(valuesData.begin(), fillValues.begin(), fillValues.end());
                     }
                 }
                 // Same for the end of the data
                 auto maxXAxisData = xAxisData.back();
                 if (!std::isnan(maxBound) && maxBound > maxXAxisData) {
                     auto holeSize = static_cast<int>((maxBound - maxXAxisData) / resolution);
                     if (holeSize > 0) {
                         xAxisData.insert(xAxisData.end(), maxXAxisData + holeSize * resolution);
                         valuesData.insert(valuesData.end(), fillValues.begin(), fillValues.end());
                     }
                 }
                 // Generates other data holes
                 auto xAxisIt = xAxisData.begin();
                 while (xAxisIt != xAxisData.end()) {
                     // Stops at first value which has a gap greater than resolution with the value next to it
                     xAxisIt = std::adjacent_find(
                         xAxisIt, xAxisData.end(),
                         [resolution](const auto &a, const auto &b) { return (b - a) > resolution; });
                     if (xAxisIt != xAxisData.end()) {
                         auto nextXAxisIt = xAxisIt + 1;
                         // Gets the values that has a gap greater than resolution between them
                         auto lowValue = *xAxisIt;
                         auto highValue = *nextXAxisIt;
                         // Completes holes between the two values by creating new values (according to the
                         // resolution)
                         for (auto i = lowValue + resolution; i < highValue; i += resolution) {
                             // Gets the iterator of values data from which to insert fill values
                             auto nextValuesIt = valuesData.begin()
                                                 + std::distance(xAxisData.begin(), nextXAxisIt) * nbComponents;
                             // New value is inserted before nextXAxisIt
                             nextXAxisIt = xAxisData.insert(nextXAxisIt, i) + 1;
                             // New values are inserted before nextValuesIt
                             valuesData.insert(nextValuesIt, fillValues.begin(), fillValues.end());
                         }
                         // Moves to the next value to continue loop on the x-axis data
                         xAxisIt = nextXAxisIt;
                     }
                 }
             }
             namespace {
             /**
              * Generates axis's mesh properties according to data and resolution
              * @param begin the iterator pointing to the beginning of the data
              * @param end the iterator pointing to the end of the data
              * @param fun the function to retrieve data from the data iterators
              * @param resolution the resolution to use for the axis' mesh
              * @return a tuple representing the mesh properties : <nb values, min value, value step>
              */
             template <typename Iterator, typename IteratorFun>
             std::tuple<int, double, double> meshProperties(Iterator begin, Iterator end, IteratorFun fun,
                                                            double resolution)
             {
                 // Computes the gap between min and max data. This will be used to determinate the step between
                 // each data of the mesh
                 auto min = fun(begin);
                 auto max = fun(end - 1);
                 auto gap = max - min;
                 // Computes the step trying to use the fixed resolution. If the resolution doesn't separate the
                 // values evenly , it is recalculated.
                 // For example, for a resolution of 2.0:
                 // - for interval [0; 8] => resolution is valid, the generated mesh will be [0, 2, 4, 6, 8]
                 // - for interval [0; 9] => it's impossible to create a regular mesh with this resolution
                 // The resolution is recalculated and is worth 1.8. The generated mesh will be [0, 1.8, 3.6,
                 // 5.4, 7.2, 9]
                 auto nbVal = static_cast<int>(std::ceil(gap / resolution));
                 auto step = gap / nbVal;
                 // last data is included in the total number of values
                 return std::make_tuple(nbVal + 1, min, step);
             }
             } // namespace
             DataSeriesUtils::Mesh DataSeriesUtils::regularMesh(DataSeriesIterator begin, DataSeriesIterator end,
                                                                Resolution xResolution, Resolution yResolution)
             {
                 // Checks preconditions
                 if (xResolution.m_Val == 0. || std::isnan(xResolution.m_Val) || yResolution.m_Val == 0.
                     || std::isnan(yResolution.m_Val)) {
                     qCWarning(LOG_DataSeriesUtils()) << "Can't generate mesh with a null resolution";
                     return Mesh{};
                 }
                 if (xResolution.m_Logarithmic) {
                     qCWarning(LOG_DataSeriesUtils())
                         << "Can't generate mesh with a logarithmic x-axis resolution";
                     return Mesh{};
                 }
                 if (std::distance(begin, end) == 0) {
                     qCWarning(LOG_DataSeriesUtils()) << "Can't generate mesh for empty data";
                     return Mesh{};
                 }
                 auto yData = begin->y();
                 if (yData.empty()) {
                     qCWarning(LOG_DataSeriesUtils()) << "Can't generate mesh for data with no y-axis";
                     return Mesh{};
                 }
                 // Converts y-axis and its resolution to logarithmic values
                 if (yResolution.m_Logarithmic) {
                     std::for_each(yData.begin(), yData.end(), [](auto &val) { val = std::log10(val); });
                 }
                 // Computes mesh properties
                 int nbX, nbY;
                 double xMin, xStep, yMin, yStep;
                 std::tie(nbX, xMin, xStep)
                     = meshProperties(begin, end, [](const auto &it) { return it->x(); }, xResolution.m_Val);
                 std::tie(nbY, yMin, yStep) = meshProperties(
                     yData.begin(), yData.end(), [](const auto &it) { return *it; }, yResolution.m_Val);
                 // Generates mesh according to the x-axis and y-axis steps
                 Mesh result{nbX, xMin, xStep, nbY, yMin, yStep};
                 for (auto meshXIndex = 0; meshXIndex < nbX; ++meshXIndex) {
                     auto meshX = xMin + meshXIndex * xStep;
                     // According to current x-axis of the mesh, finds in the data series the interval in which
                     // the data is or gets closer (without exceeding it).
                     // An interval is defined by a value and extends to +/- 50% of the resolution. For example,
                     // for a value of 3 and a resolution of 1, the associated interval is [2.5, 3.5].
                     auto xIt = std::lower_bound(begin, end, meshX,
                                                 [xResolution](const auto &it, const auto &val) {
                                                     return it.x() - xResolution.m_Val / 2. < val;
                                                 })
                                - 1;
                     // When the corresponding entry of the data series is found, generates the values of the
                     // mesh by retrieving the values of the entry, for each y-axis value of the mesh
                     auto values = xIt->values();
                     for (auto meshYIndex = 0; meshYIndex < nbY; ++meshYIndex) {
                         auto meshY = yMin + meshYIndex * yStep;
                         auto yBegin = yData.begin();
                         auto yIt = std::lower_bound(yBegin, yData.end(), meshY,
                                                     [yResolution](const auto &it, const auto &val) {
                                                         return it - yResolution.m_Val / 2. < val;
                                                     })
                                    - 1;
                         auto valueIndex = std::distance(yBegin, yIt);
                         result.m_Data[result.m_NbX * meshYIndex + meshXIndex] = values.at(valueIndex);
                     }
                 }
                 return result;
             }

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