GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r573:575eda7156d0

Add impletation for displaying data that are already in cache when...

perrinel -

r573:575eda7156d0

parent child

Context file:

r573:575eda7156d0

gui/src/Visualization/VisualizationGraphHelper.cpp +7 -23

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Data/ScalarSeries.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();
                 }
             }
             void updateScalarData(QCPAbstractPlottable *component, std::shared_ptr<ScalarSeries> scalarSeries,
-                                  const SqpRange &dateTime)
+                                  const SqpRange &range)
             {
                 qCDebug(LOG_VisualizationGraphHelper()) << "TORM: updateScalarData"
                                                         << QThread::currentThread()->objectName();
                 if (auto qcpGraph = dynamic_cast<QCPGraph *>(component)) {
                     scalarSeries->lockRead();
                     {
-            //            auto bounds = scalarSeries->subData(rang
+                        auto sqpDataContainer = QSharedPointer<SqpDataContainer>::create();
-            //            const auto &xData = scalarSeries->xAxisData()->cdata();
+                        qcpGraph->setData(sqpDataContainer);
-            //            const auto &valuesData = scalarSeries->valuesData()->cdata();
+                        auto bounds = scalarSeries->subData(range.m_TStart, range.m_TEnd);
+                        for (auto it = bounds.first; it != bounds.second; ++it) {
-            //            auto xDataBegin = xData.cbegin();
+                            sqpDataContainer->appendGraphData(QCPGraphData(it->x(), it->value()));
-            //            auto xDataEnd = xData.cend();
-            //            qCInfo(LOG_VisualizationGraphHelper()) << "TODEBUG: Current points in cache"
-            //                                                   << xData.count();
-            //            auto sqpDataContainer = QSharedPointer<SqpDataContainer>::create();
-            //            qcpGraph->setData(sqpDataContainer);
-            //            auto lowerIt = std::lower_bound(xDataBegin, xDataEnd, dateTime.m_TStart);
-            //            auto upperIt = std::upper_bound(xDataBegin, xDataEnd, dateTime.m_TEnd);
-            //            auto distance = std::distance(xDataBegin, lowerIt);
-            //            auto valuesDataIt = valuesData.cbegin() + distance;
-            //            for (auto xAxisDataIt = lowerIt; xAxisDataIt != upperIt;
-            //                 ++xAxisDataIt, ++valuesDataIt) {
-            //                sqpDataContainer->appendGraphData(QCPGraphData(*xAxisDataIt, *valuesDataIt));
-            //            }
                         qCInfo(LOG_VisualizationGraphHelper()) << "TODEBUG: Current points displayed"
                                                                << sqpDataContainer->size();
                     }
                     scalarSeries->unlock();
                     // Display all data
                     component->parentPlot()->replot();
                 }
                 else {
                     /// @todo DEBUG
                 }
             }
             QCPAbstractPlottable *createScalarSeriesComponentV2(std::shared_ptr<ScalarSeries> scalarSeries,
                                                                 QCustomPlot &plot)
             {
                 auto component = plot.addGraph();
                 if (component) {
                     // Axes properties
                     /// @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, scalarSeries->xAxisUnit());
                     setAxisProperties(plot.yAxis, scalarSeries->valuesUnit());
                 }
                 return component;
             }
             QCPAbstractPlottable *createScalarSeriesComponent(std::shared_ptr<ScalarSeries> scalarSeries,
                                                               QCustomPlot &plot, const SqpRange &dateTime)
             {
                 auto component = plot.addGraph();
                 if (component) {
                     //        // Graph data
                     component->setData(scalarSeries->xAxisData()->data(), scalarSeries->valuesData()->data(),
                                        true);
                     updateScalarData(component, scalarSeries, dateTime);
                     // Axes properties
                     /// @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, scalarSeries->xAxisUnit());
                     setAxisProperties(plot.yAxis, scalarSeries->valuesUnit());
                     // Display all data
                     component->rescaleAxes();
                     plot.replot();
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph for the scalar series");
                 }
                 return component;
             }
             } // namespace
             QVector<QCPAbstractPlottable *>
             VisualizationGraphHelper::createV2(std::shared_ptr<Variable> variable, QCustomPlot &plot) noexcept
             {
                 auto result = QVector<QCPAbstractPlottable *>{};
                 if (variable) {
                     // Gets the data series of the variable to call the creation of the right components
                     // according to its type
                     if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(variable->dataSeries())) {
                         result.append(createScalarSeriesComponentV2(scalarSeries, plot));
                     }
                     else {
                         qCDebug(LOG_VisualizationGraphHelper())
                             << QObject::tr("Can't create graph plottables : unmanaged data series type");
                     }
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                 }
                 return result;
             }
             QVector<QCPAbstractPlottable *> VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
                                                                              QCustomPlot &plot) noexcept
             {
                 auto result = QVector<QCPAbstractPlottable *>{};
                 if (variable) {
                     // Gets the data series of the variable to call the creation of the right components
                     // according to its type
                     if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(variable->dataSeries())) {
                         result.append(createScalarSeriesComponent(scalarSeries, plot, variable->range()));
                     }
                     else {
                         qCDebug(LOG_VisualizationGraphHelper())
                             << QObject::tr("Can't create graph plottables : unmanaged data series type");
                     }
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                 }
                 return result;
             }
             void VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *> plotableVect,
                                                       std::shared_ptr<IDataSeries> dataSeries,
                                                       const SqpRange &dateTime)
             {
                 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
                     if (plotableVect.size() == 1) {
                         updateScalarData(plotableVect.at(0), scalarSeries, dateTime);
                     }
                     else {
                         qCCritical(LOG_VisualizationGraphHelper()) << QObject::tr(
                             "Can't update Data of a scalarSeries because there is not only one component "
                             "associated");
                     }
                 }
                 else {
                     /// @todo DEBUG
                 }
             }

plugins/amda/tests/TestAmdaResultParser.cpp +4 -4

             #include "AmdaResultParser.h"
             #include <Data/ScalarSeries.h>
             #include <Data/VectorSeries.h>
             #include <QObject>
             #include <QtTest>
             namespace {
             /// Path for the tests
             const auto TESTS_RESOURCES_PATH
                 = QFileInfo{QString{AMDA_TESTS_RESOURCES_DIR}, "TestAmdaResultParser"}.absoluteFilePath();
             QDateTime dateTime(int year, int month, int day, int hours, int minutes, int seconds)
             {
                 return QDateTime{{year, month, day}, {hours, minutes, seconds}, Qt::UTC};
             }
             /// Compares two vectors that can potentially contain NaN values
             bool compareVectors(const QVector<double> &v1, const QVector<double> &v2)
             {
                 if (v1.size() != v2.size()) {
                     return false;
                 }
                 auto result = true;
                 auto v2It = v2.cbegin();
                 for (auto v1It = v1.cbegin(), v1End = v1.cend(); v1It != v1End && result; ++v1It, ++v2It) {
                     auto v1Value = *v1It;
                     auto v2Value = *v2It;
                     // If v1 is NaN, v2 has to be NaN too
                     result = std::isnan(v1Value) ? std::isnan(v2Value) : (v1Value == v2Value);
                 }
                 return result;
             }
             bool compareVectors(const QVector<QVector<double> > &v1, const QVector<QVector<double> > &v2)
             {
                 if (v1.size() != v2.size()) {
                     return false;
                 }
                 auto result = true;
                 for (auto i = 0; i < v1.size() && result; ++i) {
                     result &= compareVectors(v1.at(i), v2.at(i));
                 }
                 return result;
             }
             QVector<QVector<double> > valuesData(const ArrayData<1> &arrayData)
             {
                 return QVector<QVector<double> >{arrayData.data()};
             }
             QVector<QVector<double> > valuesData(const ArrayData<2> &arrayData)
             {
                 return arrayData.data();
             }
             QString inputFilePath(const QString &inputFileName)
             {
                 return QFileInfo{TESTS_RESOURCES_PATH, inputFileName}.absoluteFilePath();
             }
             template <typename T>
             struct ExpectedResults {
                 explicit ExpectedResults() = default;
                 explicit ExpectedResults(Unit xAxisUnit, Unit valuesUnit, const QVector<QDateTime> &xAxisData,
                                          QVector<double> valuesData)
                         : ExpectedResults(xAxisUnit, valuesUnit, xAxisData,
                                           QVector<QVector<double> >{std::move(valuesData)})
                 {
                 }
                 /// Ctor with QVector<QDateTime> as x-axis data. Datetimes are converted to doubles
                 explicit ExpectedResults(Unit xAxisUnit, Unit valuesUnit, const QVector<QDateTime> &xAxisData,
                                          QVector<QVector<double> > valuesData)
                         : m_ParsingOK{true},
                           m_XAxisUnit{xAxisUnit},
                           m_ValuesUnit{valuesUnit},
                           m_XAxisData{},
                           m_ValuesData{std::move(valuesData)}
                 {
                     // Converts QVector<QDateTime> to QVector<double>
                     std::transform(xAxisData.cbegin(), xAxisData.cend(), std::back_inserter(m_XAxisData),
                                    [](const auto &dateTime) { return dateTime.toMSecsSinceEpoch() / 1000.; });
                 }
                 /**
                  * Validates a DataSeries compared to the expected results
                  * @param results the DataSeries to validate
                  */
                 void validate(std::shared_ptr<IDataSeries> results)
                 {
                     if (m_ParsingOK) {
                         auto dataSeries = dynamic_cast<T *>(results.get());
                         QVERIFY(dataSeries != nullptr);
                         // Checks units
                         QVERIFY(dataSeries->xAxisUnit() == m_XAxisUnit);
                         QVERIFY(dataSeries->valuesUnit() == m_ValuesUnit);
                         // Checks values : as the vectors can potentially contain NaN values, we must use a
                         // custom vector comparison method
                         QVERIFY(compareVectors(dataSeries->xAxisData()->data(), m_XAxisData));
                         QVERIFY(compareVectors(valuesData(*dataSeries->valuesData()), m_ValuesData));
                     }
                     else {
                         QVERIFY(results == nullptr);
                     }
                 }
                 // Parsing was successfully completed
                 bool m_ParsingOK{false};
                 // Expected x-axis unit
                 Unit m_XAxisUnit{};
                 // Expected values unit
                 Unit m_ValuesUnit{};
                 // Expected x-axis data
                 QVector<double> m_XAxisData{};
                 // Expected values data
                 QVector<QVector<double> > m_ValuesData{};
             };
             } // namespace
             Q_DECLARE_METATYPE(ExpectedResults<ScalarSeries>)
             Q_DECLARE_METATYPE(ExpectedResults<VectorSeries>)
             class TestAmdaResultParser : public QObject {
                 Q_OBJECT
             private:
                 template <typename T>
                 void testReadDataStructure()
                 {
                     // ////////////// //
                     // Test structure //
                     // ////////////// //
                     // Name of TXT file to read
                     QTest::addColumn<QString>("inputFileName");
                     // Expected results
                     QTest::addColumn<ExpectedResults<T> >("expectedResults");
                 }
                 template <typename T>
                 void testRead(AmdaResultParser::ValueType valueType)
                 {
                     QFETCH(QString, inputFileName);
                     QFETCH(ExpectedResults<T>, expectedResults);
                     // Parses file
                     auto filePath = inputFilePath(inputFileName);
                     auto results = AmdaResultParser::readTxt(filePath, valueType);
                     // ///////////////// //
                     // Validates results //
                     // ///////////////// //
                     expectedResults.validate(results);
                 }
             private slots:
                 /// Input test data
                 /// @sa testReadScalarTxt()
                 void testReadScalarTxt_data();
                 /// Tests parsing scalar series of a TXT file
                 void testReadScalarTxt();
                 /// Input test data
                 /// @sa testReadVectorTxt()
                 void testReadVectorTxt_data();
                 /// Tests parsing vector series of a TXT file
                 void testReadVectorTxt();
             };
             void TestAmdaResultParser::testReadScalarTxt_data()
             {
                 testReadDataStructure<ScalarSeries>();
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 // Valid files
                 QTest::newRow("Valid file")
                     << QStringLiteral("ValidScalar1.txt")
                     << ExpectedResults<ScalarSeries>{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                               dateTime(2013, 9, 23, 9, 2, 30), dateTime(2013, 9, 23, 9, 3, 30),
                                               dateTime(2013, 9, 23, 9, 4, 30), dateTime(2013, 9, 23, 9, 5, 30),
                                               dateTime(2013, 9, 23, 9, 6, 30), dateTime(2013, 9, 23, 9, 7, 30),
                                               dateTime(2013, 9, 23, 9, 8, 30), dateTime(2013, 9, 23, 9, 9, 30)},
                            QVector<double>{-2.83950, -2.71850, -2.52150, -2.57633, -2.58050, -2.48325, -2.63025,
                                            -2.55800, -2.43250, -2.42200}};
                 QTest::newRow("Valid file (value of first line is invalid but it is converted to NaN")
                     << QStringLiteral("WrongValue.txt")
                     << ExpectedResults<ScalarSeries>{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                               dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{std::numeric_limits<double>::quiet_NaN(), -2.71850, -2.52150}};
                 QTest::newRow("Valid file that contains NaN values")
                     << QStringLiteral("NaNValue.txt")
                     << ExpectedResults<ScalarSeries>{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 0, 30), dateTime(2013, 9, 23, 9, 1, 30),
                                               dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{std::numeric_limits<double>::quiet_NaN(), -2.71850, -2.52150}};
                 // Valid files but with some invalid lines (wrong unit, wrong values, etc.)
                 QTest::newRow("No unit file") << QStringLiteral("NoUnit.txt")
                                               << ExpectedResults<ScalarSeries>{Unit{QStringLiteral(""), true},
                                                                                Unit{}, QVector<QDateTime>{},
                                                                                QVector<double>{}};
                 QTest::newRow("Wrong unit file")
                     << QStringLiteral("WrongUnit.txt")
                     << ExpectedResults<ScalarSeries>{Unit{QStringLiteral(""), true}, Unit{},
                                                      QVector<QDateTime>{dateTime(2013, 9, 23, 9, 0, 30),
                                                                         dateTime(2013, 9, 23, 9, 1, 30),
                                                                         dateTime(2013, 9, 23, 9, 2, 30)},
                                                      QVector<double>{-2.83950, -2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (date of first line is invalid")
                     << QStringLiteral("WrongDate.txt")
                     << ExpectedResults<ScalarSeries>{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (too many values for first line")
                     << QStringLiteral("TooManyValues.txt")
                     << ExpectedResults<ScalarSeries>{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Wrong results file (x of first line is NaN")
                     << QStringLiteral("NaNX.txt")
                     << ExpectedResults<ScalarSeries>{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 9, 23, 9, 1, 30), dateTime(2013, 9, 23, 9, 2, 30)},
                            QVector<double>{-2.71850, -2.52150}};
                 QTest::newRow("Invalid file type (vector)")
                     << QStringLiteral("ValidVector1.txt")
                     << ExpectedResults<ScalarSeries>{Unit{QStringLiteral("nT"), true}, Unit{},
                                                      QVector<QDateTime>{}, QVector<double>{}};
                 // Invalid files
-                QTest::newRow("Invalid file (unexisting file)")
+                QTest::newRow("Invalid file (unexisting file)") << QStringLiteral("UnexistingFile.txt")
-                    << QStringLiteral("UnexistingFile.txt") << ExpectedResults<ScalarSeries>{};
+                                                                << ExpectedResults<ScalarSeries>{};
-                QTest::newRow("Invalid file (file not found on server)")
+                QTest::newRow("Invalid file (file not found on server)") << QStringLiteral("FileNotFound.txt")
-                    << QStringLiteral("FileNotFound.txt") << ExpectedResults<ScalarSeries>{};
+                                                                         << ExpectedResults<ScalarSeries>{};
             }
             void TestAmdaResultParser::testReadScalarTxt()
             {
                 testRead<ScalarSeries>(AmdaResultParser::ValueType::SCALAR);
             }
             void TestAmdaResultParser::testReadVectorTxt_data()
             {
                 testReadDataStructure<VectorSeries>();
                 // ////////// //
                 // Test cases //
                 // ////////// //
                 // Valid files
                 QTest::newRow("Valid file")
                     << QStringLiteral("ValidVector1.txt")
                     << ExpectedResults<VectorSeries>{
                            Unit{QStringLiteral("nT"), true}, Unit{},
                            QVector<QDateTime>{dateTime(2013, 7, 2, 9, 13, 50), dateTime(2013, 7, 2, 9, 14, 6),
                                               dateTime(2013, 7, 2, 9, 14, 22), dateTime(2013, 7, 2, 9, 14, 38),
                                               dateTime(2013, 7, 2, 9, 14, 54), dateTime(2013, 7, 2, 9, 15, 10),
                                               dateTime(2013, 7, 2, 9, 15, 26), dateTime(2013, 7, 2, 9, 15, 42),
                                               dateTime(2013, 7, 2, 9, 15, 58), dateTime(2013, 7, 2, 9, 16, 14)},
                            QVector<QVector<double> >{
                                {-0.332, -1.011, -1.457, -1.293, -1.217, -1.443, -1.278, -1.202, -1.22, -1.259},
                                {3.206, 2.999, 2.785, 2.736, 2.612, 2.564, 2.892, 2.862, 2.859, 2.764},
                                {0.058, 0.496, 1.018, 1.485, 1.662, 1.505, 1.168, 1.244, 1.15, 1.358}}};
                 // Valid files but with some invalid lines (wrong unit, wrong values, etc.)
                 QTest::newRow("Invalid file type (scalar)")
                     << QStringLiteral("ValidScalar1.txt")
                     << ExpectedResults<VectorSeries>{Unit{QStringLiteral("nT"), true}, Unit{},
                                                      QVector<QDateTime>{},
                                                      QVector<QVector<double> >{{}, {}, {}}};
             }
             void TestAmdaResultParser::testReadVectorTxt()
             {
                 testRead<VectorSeries>(AmdaResultParser::ValueType::VECTOR);
             }
             QTEST_MAIN(TestAmdaResultParser)
             #include "TestAmdaResultParser.moc"

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