GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r615:e608cd04beb8

Uses variable range in graph

Alexandre Leroux -

r615:e608cd04beb8

parent child

Context file:

r615:e608cd04beb8

Collapse all files

gui/src/Visualization/VisualizationZoneWidget.cpp +14 -2

             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "ui_VisualizationZoneWidget.h"
             #include <Data/SqpRange.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QUuid>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_VisualizationZoneWidget, "VisualizationZoneWidget")
             namespace {
             /// Minimum height for graph added in zones (in pixels)
             const auto GRAPH_MINIMUM_HEIGHT = 300;
             /// Generates a default name for a new graph, according to the number of graphs already displayed in
             /// the zone
             QString defaultGraphName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationGraphWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Graph %1").arg(count + 1);
             }
             } // namespace
             struct VisualizationZoneWidget::VisualizationZoneWidgetPrivate {
                 explicit VisualizationZoneWidgetPrivate() : m_SynchronisationGroupId{QUuid::createUuid()} {}
                 QUuid m_SynchronisationGroupId;
             };
             VisualizationZoneWidget::VisualizationZoneWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationZoneWidget},
                       impl{spimpl::make_unique_impl<VisualizationZoneWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 ui->zoneNameLabel->setText(name);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationZoneWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // Synchronisation id
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronizationGroupId",
                                           Qt::QueuedConnection, Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }
             VisualizationZoneWidget::~VisualizationZoneWidget()
             {
                 delete ui;
             }
             void VisualizationZoneWidget::addGraph(VisualizationGraphWidget *graphWidget)
             {
                 ui->visualizationZoneFrame->layout()->addWidget(graphWidget);
             }
             VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<Variable> variable)
             {
                 auto graphWidget = new VisualizationGraphWidget{
                     defaultGraphName(*ui->visualizationZoneFrame->layout()), this};
                 // Set graph properties
                 graphWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
                 graphWidget->setMinimumHeight(GRAPH_MINIMUM_HEIGHT);
                 // Lambda to synchronize zone widget
                 auto synchronizeZoneWidget = [this, graphWidget](const SqpRange &graphRange,
                                                                  const SqpRange &oldGraphRange) {
                     auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                     auto frameLayout = ui->visualizationZoneFrame->layout();
                     for (auto i = 0; i < frameLayout->count(); ++i) {
                         auto graphChild
                             = dynamic_cast<VisualizationGraphWidget *>(frameLayout->itemAt(i)->widget());
                         if (graphChild && (graphChild != graphWidget)) {
                             auto graphChildRange = graphChild->graphRange();
                             switch (zoomType) {
                                 case AcquisitionZoomType::ZoomIn: {
                                     auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                                     auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaLeft;
                                     graphChildRange.m_TEnd -= deltaRight;
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                               << deltaLeft;
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                               << deltaRight;
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::ZoomOut: {
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                               << deltaLeft;
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                               << deltaRight;
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanRight: {
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaRight;
                                     graphChildRange.m_TEnd += deltaRight;
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanLeft: {
                                     qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd -= deltaLeft;
                                     break;
                                 }
                                 case AcquisitionZoomType::Unknown: {
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type unknown");
                                     break;
                                 }
                                 default:
                                     qCCritical(LOG_VisualizationZoneWidget())
                                         << tr("Impossible to synchronize: zoom type not take into account");
                                     // No action
                                     break;
                             }
                             graphChild->enableAcquisition(false);
                             qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
                                                                       << graphChild->graphRange();
                             qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
                                                                       << graphChildRange;
                             qCCritical(LOG_VisualizationZoneWidget())
                                 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                             graphChild->setGraphRange(graphChildRange);
                             graphChild->enableAcquisition(true);
                         }
                     }
                 };
                 // connection for synchronization
                 connect(graphWidget, &VisualizationGraphWidget::synchronize, synchronizeZoneWidget);
                 connect(graphWidget, &VisualizationGraphWidget::variableAdded, this,
                         &VisualizationZoneWidget::onVariableAdded);
                 auto range = SqpRange{};
                 // Apply visitor to graph children
                 auto layout = ui->visualizationZoneFrame->layout();
                 if (layout->count() > 0) {
                     // Case of a new graph in a existant zone
                     if (auto visualizationGraphWidget
                         = dynamic_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
                         range = visualizationGraphWidget->graphRange();
                     }
                 }
                 else {
                     // Case of a new graph as the first of the zone
                     range = variable->range();
                 }
                 this->addGraph(graphWidget);
                 graphWidget->addVariable(variable, range);
-                // TODO: get y using variable range
-                graphWidget->setYRange(SqpRange{-10, 10});
+                // get y using variable range
+                if (auto dataSeries = variable->dataSeries()) {
+                    auto valuesBounds = dataSeries->valuesBounds(range.m_TStart, range.m_TEnd);
+                    auto end = dataSeries->cend();
+                    if (valuesBounds.first != end && valuesBounds.second != end) {
+                        auto rangeValue = [](const auto &value) { return std::isnan(value) ? 0. : value; };
+                        auto minValue = rangeValue(valuesBounds.first->minValue());
+                        auto maxValue = rangeValue(valuesBounds.second->maxValue());
+                        graphWidget->setYRange(SqpRange{minValue, maxValue});
+                    }
+                }
                 return graphWidget;
             }
             void VisualizationZoneWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to graph children
                     auto layout = ui->visualizationZoneFrame->layout();
                     for (auto i = 0; i < layout->count(); ++i) {
                         if (auto item = layout->itemAt(i)) {
                             // Widgets different from graphs are not visited (no action)
                             if (auto visualizationGraphWidget
                                 = dynamic_cast<VisualizationGraphWidget *>(item->widget())) {
                                 visualizationGraphWidget->accept(visitor);
                             }
                         }
                     }
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationZoneWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationZoneWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationZoneWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationZoneWidget::name() const
             {
                 return ui->zoneNameLabel->text();
             }
             void VisualizationZoneWidget::onVariableAdded(std::shared_ptr<Variable> variable)
             {
                 QMetaObject::invokeMethod(&sqpApp->variableController(), "onAddSynchronized",
                                           Qt::QueuedConnection, Q_ARG(std::shared_ptr<Variable>, variable),
                                           Q_ARG(QUuid, impl->m_SynchronisationGroupId));
             }

plugins/amda/tests/TestAmdaAcquisition.cpp +1 -1

             #include "AmdaProvider.h"
             #include "AmdaResultParser.h"
             #include "SqpApplication.h"
             #include <Data/DataSeries.h>
             #include <Data/IDataSeries.h>
             #include <Data/ScalarSeries.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <QObject>
             #include <QtTest>
             #include <memory>
             // TEST with REF:
             // AmdaData-2012-01-01-12-00-00_2012-01-03-12-00-00
             // imf(0) - Type : Local Parameter @ CDPP/AMDA -
             // Name : bx_gse - Units : nT - Size : 1 -
             // Frame : GSE - Mission : ACE -
             // Instrument : MFI - Dataset : mfi_final-prelim
             // REFERENCE DOWNLOAD FILE =
             // http://amda.irap.omp.eu/php/rest/getParameter.php?startTime=2012-01-01T12:00:00&stopTime=2012-01-03T12:00:00&parameterID=imf(0)&outputFormat=ASCII&timeFormat=ISO8601&gzip=0
             namespace {
             /// Path for the tests
             const auto TESTS_RESOURCES_PATH
                 = QFileInfo{QString{AMDA_TESTS_RESOURCES_DIR}, "TestAmdaAcquisition"}.absoluteFilePath();
             const auto TESTS_AMDA_REF_FILE = QString{"AmdaData-2012-01-01-12-00-00_2012-01-03-12-00-00.txt"};
             template <typename T>
             bool compareDataSeries(std::shared_ptr<IDataSeries> candidate, SqpRange candidateCacheRange,
                                    std::shared_ptr<IDataSeries> reference)
             {
                 auto compareLambda = [](const auto &it1, const auto &it2) {
                     return (it1.x() == it2.x()) && (it1.value() == it2.value());
                 };
                 auto candidateDS = std::dynamic_pointer_cast<T>(candidate);
                 auto referenceDS = std::dynamic_pointer_cast<T>(reference);
                 if (candidateDS && referenceDS) {
                     auto itRefs
-                        = referenceDS->subData(candidateCacheRange.m_TStart, candidateCacheRange.m_TEnd);
+                        = referenceDS->xAxisRange(candidateCacheRange.m_TStart, candidateCacheRange.m_TEnd);
                     qDebug() << " DISTANCE" << std::distance(candidateDS->cbegin(), candidateDS->cend())
                              << std::distance(itRefs.first, itRefs.second);
                     //        auto xcValue = candidateDS->valuesData()->data();
                     //        auto dist = std::distance(itRefs.first, itRefs.second);
                     //        auto it = itRefs.first;
                     //        for (auto i = 0; i < dist - 1; ++i) {
                     //            ++it;
                     //            qInfo() << "END:" << it->value();
                     //        }
                     //        qDebug() << "END:" << it->value() << xcValue.last();
                     return std::equal(candidateDS->cbegin(), candidateDS->cend(), itRefs.first, itRefs.second,
                                       compareLambda);
                 }
                 else {
                     return false;
                 }
             }
             }
             class TestAmdaAcquisition : public QObject {
                 Q_OBJECT
             private slots:
                 void testAcquisition();
             };
             void TestAmdaAcquisition::testAcquisition()
             {
                 // READ the ref file:
                 auto filePath = QFileInfo{TESTS_RESOURCES_PATH, TESTS_AMDA_REF_FILE}.absoluteFilePath();
                 auto results = AmdaResultParser::readTxt(filePath, AmdaResultParser::ValueType::SCALAR);
                 auto provider = std::make_shared<AmdaProvider>();
                 auto timeController = std::make_unique<TimeController>();
                 auto varRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 3, 0, 0}};
                 auto varRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 4, 0, 0}};
                 auto sqpR = SqpRange{DateUtils::secondsSinceEpoch(varRS), DateUtils::secondsSinceEpoch(varRE)};
                 timeController->onTimeToUpdate(sqpR);
                 QVariantHash metaData;
                 metaData.insert("dataType", "scalar");
                 metaData.insert("xml:id", "imf(0)");
                 VariableController vc;
                 vc.setTimeController(timeController.get());
                 auto var = vc.createVariable("bx_gse", metaData, provider);
                 // 1 : Variable creation
                 QCOMPARE(var->range().m_TStart, sqpR.m_TStart);
                 QCOMPARE(var->range().m_TEnd, sqpR.m_TEnd);
                 qDebug() << " 1: TIMECONTROLLER" << timeController->dateTime();
                 qDebug() << " 1: RANGE     " << var->range();
                 qDebug() << " 1: CACHERANGE" << var->cacheRange();
                 // wait for 10 sec before asking next request toi permit asynchrone process to finish.
                 auto timeToWaitMs = 10000;
                 QEventLoop loop;
                 QTimer::singleShot(timeToWaitMs, &loop, &QEventLoop::quit);
                 loop.exec();
                 // Tests on acquisition operation
                 int count = 1;
                 auto requestDataLoading = [&vc, var, timeToWaitMs, results, &count](auto tStart, auto tEnd) {
                     ++count;
                     auto nextSqpR
                         = SqpRange{DateUtils::secondsSinceEpoch(tStart), DateUtils::secondsSinceEpoch(tEnd)};
                     vc.onRequestDataLoading(QVector<std::shared_ptr<Variable> >{} << var, nextSqpR,
                                             var->range(), true);
                     QEventLoop loop;
                     QTimer::singleShot(timeToWaitMs, &loop, &QEventLoop::quit);
                     loop.exec();
                     qDebug() << count << "RANGE     " << var->range();
                     qDebug() << count << "CACHERANGE" << var->cacheRange();
                     QCOMPARE(var->range().m_TStart, nextSqpR.m_TStart);
                     QCOMPARE(var->range().m_TEnd, nextSqpR.m_TEnd);
                     // Verify dataserie
                     QVERIFY(compareDataSeries<ScalarSeries>(var->dataSeries(), var->cacheRange(), results));
                 };
                 // 2 : pan (jump) left for one hour
                 auto nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 1, 0, 0}};
                 auto nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 2, 0, 0}};
                 // requestDataLoading(nextVarRS, nextVarRE);
                 // 3 : pan (jump) right for one hour
                 nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 5, 0, 0}};
                 nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 6, 0, 0}};
                 requestDataLoading(nextVarRS, nextVarRE);
                 // 4 : pan (overlay) right for 30 min
                 nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 5, 30, 0}};
                 nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 6, 30, 0}};
                 // requestDataLoading(nextVarRS, nextVarRE);
                 // 5 : pan (overlay) left for 30 min
                 nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 5, 0, 0}};
                 nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 6, 0, 0}};
                 // requestDataLoading(nextVarRS, nextVarRE);
                 // 6 : pan (overlay) left for 30 min - BIS
                 nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 4, 30, 0}};
                 nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 5, 30, 0}};
                 // requestDataLoading(nextVarRS, nextVarRE);
                 // 7 : Zoom in Inside 20 min range
                 nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 4, 50, 0}};
                 nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 5, 10, 0}};
                 // requestDataLoading(nextVarRS, nextVarRE);
                 // 8 : Zoom out Inside 2 hours range
                 nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 4, 0, 0}};
                 nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 6, 0, 0}};
                 // requestDataLoading(nextVarRS, nextVarRE);
                 // Close the app after 10 sec
                 QTimer::singleShot(timeToWaitMs, &loop, &QEventLoop::quit);
                 loop.exec();
             }
             int main(int argc, char *argv[])
             {
                 SqpApplication app(argc, argv);
                 app.setAttribute(Qt::AA_Use96Dpi, true);
                 TestAmdaAcquisition tc;
                 QTEST_SET_MAIN_SOURCE_PATH
                 return QTest::qExec(&tc, argc, argv);
             }
             // QTEST_MAIN(TestAmdaAcquisition)
             #include "TestAmdaAcquisition.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