GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r990:2da9b0f28a10

Spectrograms implementation (1)...

Alexandre Leroux -

r990:2da9b0f28a10

parent child

Context file:

r990:2da9b0f28a10

Collapse all files

plugins/amda/include/AmdaResultParser.h +1 -1

             #ifndef SCIQLOP_AMDARESULTPARSER_H
             #define SCIQLOP_AMDARESULTPARSER_H
             #include "AmdaGlobal.h"
             #include <QLoggingCategory>
             #include <memory>
             class IDataSeries;
             Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaResultParser)
             struct SCIQLOP_AMDA_EXPORT AmdaResultParser {
-                enum class ValueType { SCALAR, VECTOR, UNKNOWN };
+                enum class ValueType { SCALAR, SPECTROGRAM, VECTOR, UNKNOWN };
                 static std::shared_ptr<IDataSeries> readTxt(const QString &filePath,
                                                             ValueType valueType) noexcept;
             };
             #endif // SCIQLOP_AMDARESULTPARSER_H

plugins/amda/include/AmdaResultParserHelper.h +11 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;
+            };
+            /**
              * 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/AmdaProvider.cpp +3 0

             #include "AmdaProvider.h"
             #include "AmdaDefs.h"
             #include "AmdaResultParser.h"
             #include <Common/DateUtils.h>
             #include <Data/DataProviderParameters.h>
             #include <Network/NetworkController.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <QNetworkAccessManager>
             #include <QNetworkReply>
             #include <QTemporaryFile>
             #include <QThread>
             Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
             namespace {
             /// URL of the default AMDA server
             const auto AMDA_SERVER_URL = QStringLiteral("amda.irap.omp.eu");
             /// URL of the AMDA test server
             const auto AMDA_TEST_SERVER_URL = QStringLiteral("amdatest.irap.omp.eu");
             /// URL format for a request on AMDA server. The parameters are as follows:
             /// - %1: server URL
             /// - %2: start date
             /// - %3: end date
             /// - %4: parameter id
             /// AMDA V2: http://amdatest.irap.omp.eu/php/rest/
             const auto AMDA_URL_FORMAT = QStringLiteral(
                 "http://%1/php/rest/"
                 "getParameter.php?startTime=%2&stopTime=%3&parameterID=%4&outputFormat=ASCII&"
                 "timeFormat=ISO8601&gzip=0");
             /// Dates format passed in the URL (e.g 2013-09-23T09:00)
             const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
             /// Formats a time to a date that can be passed in URL
             QString dateFormat(double sqpRange) noexcept
             {
                 auto dateTime = DateUtils::dateTime(sqpRange);
                 return dateTime.toString(AMDA_TIME_FORMAT);
             }
             /// Returns the URL of the AMDA server queried for requests, depending on the type of server passed
             /// as a parameter
             QString serverURL(const QString &server)
             {
                 if (server == QString{"amdatest"}) {
                     return AMDA_TEST_SERVER_URL;
                 }
                 else {
                     return AMDA_SERVER_URL;
                 }
             }
             AmdaResultParser::ValueType valueType(const QString &valueType)
             {
                 if (valueType == QStringLiteral("scalar")) {
                     return AmdaResultParser::ValueType::SCALAR;
                 }
+                else if (valueType == QStringLiteral("spectrogram")) {
+                    return AmdaResultParser::ValueType::SPECTROGRAM;
+                }
                 else if (valueType == QStringLiteral("vector")) {
                     return AmdaResultParser::ValueType::VECTOR;
                 }
                 else {
                     return AmdaResultParser::ValueType::UNKNOWN;
                 }
             }
             } // namespace
             AmdaProvider::AmdaProvider()
             {
                 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     connect(this, SIGNAL(requestConstructed(std::shared_ptr<QNetworkRequest>, QUuid,
                                                             std::function<void(QNetworkReply *, QUuid)>)),
                             &networkController,
                             SLOT(onProcessRequested(std::shared_ptr<QNetworkRequest>, QUuid,
                                                     std::function<void(QNetworkReply *, QUuid)>)));
                     connect(&sqpApp->networkController(),
                             SIGNAL(replyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)),
                             this,
                             SLOT(onReplyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)));
                 }
             }
             std::shared_ptr<IDataProvider> AmdaProvider::clone() const
             {
                 // No copy is made in the clone
                 return std::make_shared<AmdaProvider>();
             }
             void AmdaProvider::requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters)
             {
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 const auto data = parameters.m_Data;
                 for (const auto &dateTime : qAsConst(times)) {
                     qCDebug(LOG_AmdaProvider()) << tr("TORM AmdaProvider::requestDataLoading ") << acqIdentifier
                                                 << dateTime;
                     this->retrieveData(acqIdentifier, dateTime, data);
                     // TORM when AMDA will support quick asynchrone request
                     QThread::msleep(1000);
                 }
             }
             void AmdaProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 if (auto app = sqpApp) {
                     auto &networkController = app->networkController();
                     networkController.onReplyCanceled(acqIdentifier);
                 }
             }
             void AmdaProvider::onReplyDownloadProgress(QUuid acqIdentifier,
                                                        std::shared_ptr<QNetworkRequest> networkRequest,
                                                        double progress)
             {
                 qCDebug(LOG_AmdaProvider()) << tr("onReplyDownloadProgress") << acqIdentifier
                                             << networkRequest.get() << progress;
                 auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                     // Update the progression for the current request
                     auto requestPtr = networkRequest;
                     auto findRequest = [requestPtr](const auto &entry) { return requestPtr == entry.first; };
                     auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                     auto requestProgressMapEnd = requestProgressMap.end();
                     auto requestProgressMapIt
                         = std::find_if(requestProgressMap.begin(), requestProgressMapEnd, findRequest);
                     if (requestProgressMapIt != requestProgressMapEnd) {
                         requestProgressMapIt->second = progress;
                     }
                     else {
                         // This case can happened when a progression is send after the request has been
                         // finished.
                         // Generaly the case when aborting a request
                         qCDebug(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress") << acqIdentifier
                                                     << networkRequest.get() << progress;
                     }
                     // Compute the current final progress and notify it
                     double finalProgress = 0.0;
                     auto fraq = requestProgressMap.size();
                     for (auto requestProgress : requestProgressMap) {
                         finalProgress += requestProgress.second;
                         qCDebug(LOG_AmdaProvider()) << tr("Current final progress without fraq:")
                                                     << finalProgress << requestProgress.second;
                     }
                     if (fraq > 0) {
                         finalProgress = finalProgress / fraq;
                     }
                     qCDebug(LOG_AmdaProvider()) << tr("Current final progress: ") << fraq << finalProgress;
                     emit dataProvidedProgress(acqIdentifier, finalProgress);
                 }
                 else {
                     // This case can happened when a progression is send after the request has been finished.
                     // Generaly the case when aborting a request
                     emit dataProvidedProgress(acqIdentifier, 100.0);
                 }
             }
             void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)
             {
                 // Retrieves product ID from data: if the value is invalid, no request is made
                 auto productId = data.value(AMDA_XML_ID_KEY).toString();
                 if (productId.isNull()) {
                     qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
                     return;
                 }
                 // Retrieves the data type that determines whether the expected format for the result file is
                 // scalar, vector...
                 auto productValueType = valueType(data.value(AMDA_DATA_TYPE_KEY).toString());
                 // Gets the server being queried to retrieve the product. It's then used to set the server URL
                 auto productServer = data.value(AMDA_SERVER_KEY).toString();
                 // /////////// //
                 // Creates URL //
                 // /////////// //
                 auto startDate = dateFormat(dateTime.m_TStart);
                 auto endDate = dateFormat(dateTime.m_TEnd);
                 auto url = QUrl{
                     QString{AMDA_URL_FORMAT}.arg(serverURL(productServer), startDate, endDate, productId)};
                 qCInfo(LOG_AmdaProvider()) << tr("TORM AmdaProvider::retrieveData url:") << url;
                 auto tempFile = std::make_shared<QTemporaryFile>();
                 // LAMBDA
                 auto httpDownloadFinished = [this, dateTime, tempFile,
                                              productValueType](QNetworkReply *reply, QUuid dataId) noexcept {
                     // Don't do anything if the reply was abort
                     if (reply->error() == QNetworkReply::NoError) {
                         if (tempFile) {
                             auto replyReadAll = reply->readAll();
                             if (!replyReadAll.isEmpty()) {
                                 tempFile->write(replyReadAll);
                             }
                             tempFile->close();
                             // Parse results file
                             if (auto dataSeries
                                 = AmdaResultParser::readTxt(tempFile->fileName(), productValueType)) {
                                 emit dataProvided(dataId, dataSeries, dateTime);
                             }
                             else {
                                 /// @todo ALX : debug
                                 emit dataProvidedFailed(dataId);
                             }
                         }
                         m_AcqIdToRequestProgressMap.erase(dataId);
                     }
                     else {
                         qCCritical(LOG_AmdaProvider()) << tr("httpDownloadFinished ERROR");
                         emit dataProvidedFailed(dataId);
                     }
                 };
                 auto httpFinishedLambda
                     = [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
                           // Don't do anything if the reply was abort
                           if (reply->error() == QNetworkReply::NoError) {
                               auto downloadFileUrl = QUrl{QString{reply->readAll()}.trimmed()};
                               qCInfo(LOG_AmdaProvider())
                                   << tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;
                               // Executes request for downloading file //
                               // Creates destination file
                               if (tempFile->open()) {
                                   // Executes request and store the request for progression
                                   auto request = std::make_shared<QNetworkRequest>(downloadFileUrl);
                                   updateRequestProgress(dataId, request, 0.0);
                                   emit requestConstructed(request, dataId, httpDownloadFinished);
                               }
                               else {
                                   emit dataProvidedFailed(dataId);
                               }
                           }
                           else {
                               qCCritical(LOG_AmdaProvider()) << tr("httpFinishedLambda ERROR");
                               m_AcqIdToRequestProgressMap.erase(dataId);
                               emit dataProvidedFailed(dataId);
                           }
                       };
                 // //////////////// //
                 // Executes request //
                 // //////////////// //
                 auto request = std::make_shared<QNetworkRequest>(url);
                 qCDebug(LOG_AmdaProvider()) << tr("First Request creation") << request.get();
                 updateRequestProgress(token, request, 0.0);
                 emit requestConstructed(request, token, httpFinishedLambda);
             }
             void AmdaProvider::updateRequestProgress(QUuid acqIdentifier,
                                                      std::shared_ptr<QNetworkRequest> request, double progress)
             {
                 qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress request") << request.get();
                 auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                     auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                     auto requestProgressMapIt = requestProgressMap.find(request);
                     if (requestProgressMapIt != requestProgressMap.end()) {
                         requestProgressMapIt->second = progress;
                         qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new progress for request")
                                                     << acqIdentifier << request.get() << progress;
                     }
                     else {
                         qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new request") << acqIdentifier
                                                     << request.get() << progress;
                         acqIdToRequestProgressMapIt->second.insert(std::make_pair(request, progress));
                     }
                 }
                 else {
                     qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new acqIdentifier")
                                                 << acqIdentifier << request.get() << progress;
                     auto requestProgressMap = std::map<std::shared_ptr<QNetworkRequest>, double>{};
                     requestProgressMap.insert(std::make_pair(request, progress));
                     m_AcqIdToRequestProgressMap.insert(
                         std::make_pair(acqIdentifier, std::move(requestProgressMap)));
                 }
             }

plugins/amda/src/AmdaResultParser.cpp +2 0

             #include "AmdaResultParser.h"
             #include "AmdaResultParserHelper.h"
             #include <QFile>
             #include <cmath>
             Q_LOGGING_CATEGORY(LOG_AmdaResultParser, "AmdaResultParser")
             namespace {
             /// Message in result file when the file was not found on server
             const auto FILE_NOT_FOUND_MESSAGE = QStringLiteral("Not Found");
             /// Checks if a line is a comment line
             bool isCommentLine(const QString &line)
             {
                 return line.startsWith("#");
             }
             /**
              * Creates helper that will be used to read AMDA file, according to the type passed as parameter
              * @param valueType the type of values expected in the AMDA file (scalars, vectors, spectrograms...)
              * @return the helper created
              */
             std::unique_ptr<IAmdaResultParserHelper> createHelper(AmdaResultParser::ValueType valueType)
             {
                 switch (valueType) {
                     case AmdaResultParser::ValueType::SCALAR:
                         return std::make_unique<ScalarParserHelper>();
+                    case AmdaResultParser::ValueType::SPECTROGRAM:
+                        return std::make_unique<SpectrogramParserHelper>();
                     case AmdaResultParser::ValueType::VECTOR:
                         return std::make_unique<VectorParserHelper>();
                     case AmdaResultParser::ValueType::UNKNOWN:
                         // Invalid case
                         break;
                 }
                 // Invalid cases
                 qCCritical(LOG_AmdaResultParser())
                     << QObject::tr("Can't create helper to read result file: unsupported type");
                 return nullptr;
             }
             /**
              * Reads properties of the stream passed as parameter
              * @param helper the helper used to read properties line by line
              * @param stream the stream to read
              */
             void readProperties(IAmdaResultParserHelper &helper, QTextStream &stream)
             {
                 // Searches properties in the comment lines (as long as the reading has not reached the data)
                 // AMDA V2: while (stream.readLineInto(&line) && !line.contains(DATA_HEADER_REGEX)) {
                 QString line{};
                 while (stream.readLineInto(&line) && isCommentLine(line)) {
                     helper.readPropertyLine(line);
                 }
             }
             /**
              * Reads results of the stream passed as parameter
              * @param helper the helper used to read results line by line
              * @param stream the stream to read
              */
             void readResults(IAmdaResultParserHelper &helper, QTextStream &stream)
             {
                 QString line{};
                 // Skip comment lines
                 while (stream.readLineInto(&line) && isCommentLine(line)) {
                 }
                 if (!stream.atEnd()) {
                     do {
                         helper.readResultLine(line);
                     } while (stream.readLineInto(&line));
                 }
             }
             } // namespace
             std::shared_ptr<IDataSeries> AmdaResultParser::readTxt(const QString &filePath,
                                                                    ValueType valueType) noexcept
             {
                 if (valueType == ValueType::UNKNOWN) {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data: the type of values to be read is unknown");
                     return nullptr;
                 }
                 QFile file{filePath};
                 if (!file.open(QFile::ReadOnly | QIODevice::Text)) {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data from file %1: %2")
                                .arg(filePath, file.errorString());
                     return nullptr;
                 }
                 QTextStream stream{&file};
                 // Checks if the file was found on the server
                 auto firstLine = stream.readLine();
                 if (firstLine.compare(FILE_NOT_FOUND_MESSAGE) == 0) {
                     qCCritical(LOG_AmdaResultParser())
                         << QObject::tr("Can't retrieve AMDA data from file %1: file was not found on server")
                                .arg(filePath);
                     return nullptr;
                 }
                 auto helper = createHelper(valueType);
                 Q_ASSERT(helper != nullptr);
                 // Reads header file to retrieve properties
                 stream.seek(0); // returns to the beginning of the file
                 readProperties(*helper, stream);
                 // Checks properties
                 if (helper->checkProperties()) {
                     // Reads results
                     // AMDA V2: remove line
                     stream.seek(0); // returns to the beginning of the file
                     readResults(*helper, stream);
                     // Creates data series
                     return helper->createSeries();
                 }
                 else {
                     return nullptr;
                 }
             }

plugins/amda/src/AmdaResultParserHelper.cpp +24 0

             #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 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
+            }
+            std::shared_ptr<IDataSeries> SpectrogramParserHelper::createSeries()
+            {
+                /// @todo ALX
+            }
+            void SpectrogramParserHelper::readPropertyLine(const QString &line)
+            {
+                /// @todo ALX
+            }
+            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