HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r951:9171b76c9790

Spectrograms implementation (3)...

Alexandre Leroux -

r951:9171b76c9790

parent child

Context file:

r951:9171b76c9790

Collapse all files

plugins/amda/include/AmdaResultParserHelper.h +3 0

             #ifndef SCIQLOP_AMDARESULTPARSERHELPER_H
             #define SCIQLOP_AMDARESULTPARSERHELPER_H
             #include "AmdaResultParserDefs.h"
             #include <QtCore/QLoggingCategory>
             #include <QtCore/QString>
             #include <memory>
             class IDataSeries;
             Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaResultParserHelper)
             /**
              * Helper used to interpret the data of an AMDA result file and generate the corresponding data
              * series.
              *
              * It proposes methods allowing to read line by line an AMDA file and to extract the properties
              * (from the header) and the values corresponding to the data series
              *
              * @sa DataSeries
              */
             struct IAmdaResultParserHelper {
                 virtual ~IAmdaResultParserHelper() noexcept = default;
                 /// Verifies that the extracted properties are well formed and possibly applies other treatments
                 /// on them
                 /// @return true if the properties are well formed, false otherwise
                 virtual bool checkProperties() = 0;
                 /// Creates the data series from the properties and values extracted from the AMDA file.
                 /// @warning as the data are moved in the data series, the helper shouldn't be used after
                 /// calling this method
                 /// @return the data series created
                 virtual std::shared_ptr<IDataSeries> createSeries() = 0;
                 /// Reads a line from the AMDA file to extract a property that will be used to generate the data
                 /// series
                 /// @param line tahe line to interpret
                 virtual void readPropertyLine(const QString &line) = 0;
                 /// Reads a line from the AMDA file to extract a value that will be set in the data series
                 /// @param line the line to interpret
                 virtual void readResultLine(const QString &line) = 0;
             };
             /**
              * Implementation of @sa IAmdaResultParserHelper for scalars
              */
             class ScalarParserHelper : public IAmdaResultParserHelper {
             public:
                 bool checkProperties() override;
                 std::shared_ptr<IDataSeries> createSeries() override;
                 void readPropertyLine(const QString &line) override;
                 void readResultLine(const QString &line) override;
             private:
                 /// @return the reading order of the "value" columns for a result line of the AMDA file
                 std::vector<int> valuesIndexes() const;
                 Properties m_Properties{};
                 std::vector<double> m_XAxisData{};
                 std::vector<double> m_ValuesData{};
             };
             /**
              * Implementation of @sa IAmdaResultParserHelper for spectrograms
              */
             class SpectrogramParserHelper : public IAmdaResultParserHelper {
             public:
                 bool checkProperties() override;
                 std::shared_ptr<IDataSeries> createSeries() override;
                 void readPropertyLine(const QString &line) override;
                 void readResultLine(const QString &line) override;
+            private:
+                Properties m_Properties{};
             };
             /**
              * Implementation of @sa IAmdaResultParserHelper for vectors
              */
             class VectorParserHelper : public IAmdaResultParserHelper {
             public:
                 bool checkProperties() override;
                 std::shared_ptr<IDataSeries> createSeries() override;
                 void readPropertyLine(const QString &line) override;
                 void readResultLine(const QString &line) override;
             private:
                 /// @return the reading order of the "value" columns for a result line of the AMDA file
                 std::vector<int> valuesIndexes() const;
                 Properties m_Properties{};
                 std::vector<double> m_XAxisData{};
                 std::vector<double> m_ValuesData{};
             };
             #endif // SCIQLOP_AMDARESULTPARSERHELPER_H

plugins/amda/src/AmdaResultParserHelper.cpp +105 -2

             #include "AmdaResultParserHelper.h"
             #include <Common/DateUtils.h>
             #include <Data/ScalarSeries.h>
             #include <Data/Unit.h>
             #include <Data/VectorSeries.h>
             #include <QtCore/QDateTime>
             #include <QtCore/QRegularExpression>
             Q_LOGGING_CATEGORY(LOG_AmdaResultParserHelper, "AmdaResultParserHelper")
             namespace {
             // ///////// //
             // Constants //
             // ///////// //
             /// Separator between values in a result line
             const auto RESULT_LINE_SEPARATOR = QRegularExpression{QStringLiteral("\\s+")};
             /// Format for dates in result files
             const auto DATE_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss.zzz");
             // /////// //
             // Methods //
             // /////// //
             /**
              * Checks that the properties contain a specific unit and that this unit is valid
              * @param properties the properties map in which to search unit
              * @param key the key to search for the unit in the properties
              * @param errorMessage the error message to log in case the unit is invalid
              * @return true if the unit is valid, false it it's invalid or was not found in the properties
              */
             bool checkUnit(const Properties &properties, const QString &key, const QString &errorMessage)
             {
                 auto unit = properties.value(key).value<Unit>();
                 if (unit.m_Name.isEmpty()) {
                     qCWarning(LOG_AmdaResultParserHelper()) << errorMessage;
                     return false;
                 }
                 return true;
             }
             QDateTime dateTimeFromString(const QString &stringDate) noexcept
             {
             #if QT_VERSION >= QT_VERSION_CHECK(5, 8, 0)
                 return QDateTime::fromString(stringDate, Qt::ISODateWithMs);
             #else
                 return QDateTime::fromString(stringDate, DATE_FORMAT);
             #endif
             }
             /// Converts a string date to a double date
             /// @return a double that represents the date in seconds, NaN if the string date can't be converted
             double doubleDate(const QString &stringDate) noexcept
             {
                 // Format: yyyy-MM-ddThh:mm:ss.zzz
                 auto dateTime = dateTimeFromString(stringDate);
                 dateTime.setTimeSpec(Qt::UTC);
                 return dateTime.isValid() ? DateUtils::secondsSinceEpoch(dateTime)
                                           : std::numeric_limits<double>::quiet_NaN();
             }
             /**
              * Reads a line from the AMDA file and tries to extract a x-axis data and value data from it
              * @param xAxisData the vector in which to store the x-axis data extracted
              * @param valuesData the vector in which to store the value extracted
              * @param line the line to read to extract the property
              * @param valuesIndexes indexes of insertion of read values. For example, if the line contains three
              * columns of values, and valuesIndexes are {2, 0, 1}, the value of the third column will be read
              * and inserted first, then the value of the first column, and finally the value of the second
              * column.
              * @param fillValue value that tags an invalid data. For example, if fillValue is -1 and a read
              * value is -1, then this value is considered as invalid and converted to NaN
              */
             void tryReadResult(std::vector<double> &xAxisData, std::vector<double> &valuesData,
                                const QString &line, const std::vector<int> &valuesIndexes,
                                double fillValue = std::numeric_limits<double>::quiet_NaN())
             {
                 auto lineData = line.split(RESULT_LINE_SEPARATOR, QString::SkipEmptyParts);
                 // Checks that the line contains expected number of values + x-axis value
                 if (lineData.size() == valuesIndexes.size() + 1) {
                     // X : the data is converted from date to double (in secs)
                     auto x = doubleDate(lineData.at(0));
                     // Adds result only if x is valid. Then, if value is invalid, it is set to NaN
                     if (!std::isnan(x)) {
                         xAxisData.push_back(x);
                         // Values
                         for (auto valueIndex : valuesIndexes) {
                             bool valueOk;
                             // we use valueIndex + 1 to skip column 0 (x-axis value)
                             auto value = lineData.at(valueIndex + 1).toDouble(&valueOk);
                             if (!valueOk) {
                                 qCWarning(LOG_AmdaResultParserHelper())
                                     << QObject::tr(
                                            "Value from (line %1, column %2) is invalid and will be "
                                            "converted to NaN")
                                            .arg(line, valueIndex);
                                 value = std::numeric_limits<double>::quiet_NaN();
                             }
                             // Handles fill value
                             if (!std::isnan(fillValue) && !std::isnan(value) && fillValue == value) {
                                 value = std::numeric_limits<double>::quiet_NaN();
                             }
                             valuesData.push_back(value);
                         }
                     }
                     else {
                         qCWarning(LOG_AmdaResultParserHelper())
                             << QObject::tr("Can't retrieve results from line %1: x is invalid").arg(line);
                     }
                 }
                 else {
                     qCWarning(LOG_AmdaResultParserHelper())
                         << QObject::tr("Can't retrieve results from line %1: invalid line").arg(line);
                 }
             }
             /**
              * Reads a line from the AMDA file and tries to extract a property from it
              * @param properties the properties map in which to put the property extracted from the line
              * @param key the key to which the property is added in the properties map
              * @param line the line to read to extract the property
              * @param regex the expected regex to extract the property. If the line matches this regex, the
              * property is generated
              * @param fun the function used to generate the property
              * @return true if the property could be generated, false if the line does not match the regex, or
              * if a property has already been generated for the key
              */
             template <typename GeneratePropertyFun>
             bool tryReadProperty(Properties &properties, const QString &key, const QString &line,
                                  const QRegularExpression &regex, GeneratePropertyFun fun)
             {
                 if (properties.contains(key)) {
                     return false;
                 }
                 auto match = regex.match(line);
                 if (match.hasMatch()) {
                     properties.insert(key, fun(match));
                 }
                 return match.hasMatch();
             }
             /**
+             * Reads a line from the AMDA file and tries to extract a double from it
+             * @sa tryReadProperty()
+             */
+            bool tryReadDouble(Properties &properties, const QString &key, const QString &line,
+                               const QRegularExpression &regex)
+            {
+                return tryReadProperty(properties, key, line, regex, [](const auto &match) {
+                    bool ok;
+                    // If the value can't be converted to double, it is set to NaN
+                    auto doubleValue = match.captured(1).toDouble(&ok);
+                    if (!ok) {
+                        doubleValue = std::numeric_limits<double>::quiet_NaN();
+                    }
+                    return QVariant::fromValue(doubleValue);
+                });
+            }
+            /**
+             * Reads a line from the AMDA file and tries to extract a vector of doubles from it
+             * @param sep the separator of double values in the line
+             * @sa tryReadProperty()
+             */
+            bool tryReadDoubles(Properties &properties, const QString &key, const QString &line,
+                                const QRegularExpression &regex, const QString &sep = QStringLiteral(","))
+            {
+                return tryReadProperty(properties, key, line, regex, [sep](const auto &match) {
+                    std::vector<double> doubleValues{};
+                    // If the value can't be converted to double, it is set to NaN
+                    auto values = match.captured(1).split(sep);
+                    for (auto value : values) {
+                        bool ok;
+                        auto doubleValue = value.toDouble(&ok);
+                        if (!ok) {
+                            doubleValue = std::numeric_limits<double>::quiet_NaN();
+                        }
+                        doubleValues.push_back(doubleValue);
+                    }
+                    return QVariant::fromValue(doubleValues);
+                });
+            }
+            /**
              * Reads a line from the AMDA file and tries to extract a unit from it
              * @sa tryReadProperty()
              */
             bool tryReadUnit(Properties &properties, const QString &key, const QString &line,
                              const QRegularExpression &regex, bool timeUnit = false)
             {
                 return tryReadProperty(properties, key, line, regex, [timeUnit](const auto &match) {
                     return QVariant::fromValue(Unit{match.captured(1), timeUnit});
                 });
             }
             } // namespace
             // ////////////////// //
             // ScalarParserHelper //
             // ////////////////// //
             bool ScalarParserHelper::checkProperties()
             {
                 return checkUnit(m_Properties, X_AXIS_UNIT_PROPERTY,
                                  QObject::tr("The x-axis unit could not be found in the file"));
             }
             std::shared_ptr<IDataSeries> ScalarParserHelper::createSeries()
             {
                 return std::make_shared<ScalarSeries>(std::move(m_XAxisData), std::move(m_ValuesData),
                                                       m_Properties.value(X_AXIS_UNIT_PROPERTY).value<Unit>(),
                                                       m_Properties.value(VALUES_UNIT_PROPERTY).value<Unit>());
             }
             void ScalarParserHelper::readPropertyLine(const QString &line)
             {
                 tryReadUnit(m_Properties, X_AXIS_UNIT_PROPERTY, line, DEFAULT_X_AXIS_UNIT_REGEX, true);
             }
             void ScalarParserHelper::readResultLine(const QString &line)
             {
                 tryReadResult(m_XAxisData, m_ValuesData, line, valuesIndexes());
             }
             std::vector<int> ScalarParserHelper::valuesIndexes() const
             {
                 // Only one value to read
                 static auto result = std::vector<int>{0};
                 return result;
             }
             // /////////////////////// //
             // SpectrogramParserHelper //
             // /////////////////////// //
             bool SpectrogramParserHelper::checkProperties()
             {
-                /// @todo ALX
+                // Generates y-axis data from bands extracted (take the middle of the intervals)
+                auto minBands = m_Properties.value(MIN_BANDS_PROPERTY).value<std::vector<double> >();
+                auto maxBands = m_Properties.value(MAX_BANDS_PROPERTY).value<std::vector<double> >();
+                if (minBands.size() != maxBands.size()) {
+                    qCWarning(LOG_AmdaResultParserHelper()) << QObject::tr(
+                        "Can't generate y-axis data from bands extracted: bands intervals are invalid");
+                    return false;
+                }
+                return true;
             }
             std::shared_ptr<IDataSeries> SpectrogramParserHelper::createSeries()
             {
                 /// @todo ALX
             }
             void SpectrogramParserHelper::readPropertyLine(const QString &line)
             {
-                /// @todo ALX
+                // Set of functions to test on the line to generate a property. If a function is valid (i.e. a
+                // property has been generated for the line), the line is treated as processed and the other
+                // functions are not called
+                std::vector<std::function<bool()> > functions{
+                    // values unit
+                    [&] {
+                        return tryReadUnit(m_Properties, VALUES_UNIT_PROPERTY, line,
+                                           SPECTROGRAM_VALUES_UNIT_REGEX);
+                    },
+                    // y-axis unit
+                    [&] {
+                        return tryReadUnit(m_Properties, Y_AXIS_UNIT_PROPERTY, line,
+                                           SPECTROGRAM_Y_AXIS_UNIT_REGEX);
+                    },
+                    // min sampling
+                    [&] {
+                        return tryReadDouble(m_Properties, MIN_SAMPLING_PROPERTY, line,
+                                             SPECTROGRAM_MIN_SAMPLING_REGEX);
+                    },
+                    // max sampling
+                    [&] {
+                        return tryReadDouble(m_Properties, MAX_SAMPLING_PROPERTY, line,
+                                             SPECTROGRAM_MAX_SAMPLING_REGEX);
+                    },
+                    // fill value
+                    [&] {
+                        return tryReadDouble(m_Properties, FILL_VALUE_PROPERTY, line,
+                                             SPECTROGRAM_FILL_VALUE_REGEX);
+                    },
+                    // min bounds of each band
+                    [&] {
+                        return tryReadDoubles(m_Properties, MIN_BANDS_PROPERTY, line,
+                                              SPECTROGRAM_MIN_BANDS_REGEX);
+                    },
+                    // max bounds of each band
+                    [&] {
+                        return tryReadDoubles(m_Properties, MAX_BANDS_PROPERTY, line,
+                                              SPECTROGRAM_MAX_BANDS_REGEX);
+                    }};
+                for (auto function : functions) {
+                    // Stops at the first function that is valid
+                    if (function()) {
+                        return;
+                    }
+                }
             }
             void SpectrogramParserHelper::readResultLine(const QString &line)
             {
                 /// @todo ALX
             }
             // ////////////////// //
             // VectorParserHelper //
             // ////////////////// //
             bool VectorParserHelper::checkProperties()
             {
                 return checkUnit(m_Properties, X_AXIS_UNIT_PROPERTY,
                                  QObject::tr("The x-axis unit could not be found in the file"));
             }
             std::shared_ptr<IDataSeries> VectorParserHelper::createSeries()
             {
                 return std::make_shared<VectorSeries>(std::move(m_XAxisData), std::move(m_ValuesData),
                                                       m_Properties.value(X_AXIS_UNIT_PROPERTY).value<Unit>(),
                                                       m_Properties.value(VALUES_UNIT_PROPERTY).value<Unit>());
             }
             void VectorParserHelper::readPropertyLine(const QString &line)
             {
                 tryReadUnit(m_Properties, X_AXIS_UNIT_PROPERTY, line, DEFAULT_X_AXIS_UNIT_REGEX, true);
             }
             void VectorParserHelper::readResultLine(const QString &line)
             {
                 tryReadResult(m_XAxisData, m_ValuesData, line, valuesIndexes());
             }
             std::vector<int> VectorParserHelper::valuesIndexes() const
             {
                 // 3 values to read, in order in the file (x, y, z)
                 static auto result = std::vector<int>{0, 1, 2};
                 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