GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r908:9ee11b23a95d

(Minor) Removes obsolete code

Alexandre Leroux -

r908:9ee11b23a95d

parent child

Context file:

r908:9ee11b23a95d

Collapse all files

core/tests/Data/TestSpectrogramSeries.cpp 0 -1

             #include "Data/SpectrogramSeries.h"
             #include "DataSeriesBuilders.h"
             #include "DataSeriesUtils.h"
             #include <QObject>
             #include <QtTest>
             namespace {
             // Aliases used to facilitate reading of test inputs
             using X = DataContainer;
             using Y = DataContainer;
             using Values = DataContainer;
             using Components = std::vector<DataContainer>;
             } // namespace
             /**
              * @brief The TestSpectrogramSeries class defines unit tests on spectrogram series.
              *
              * Most of these unit tests use generic tests defined for DataSeries (@sa DataSeriesUtils)
              */
             class TestSpectrogramSeries : public QObject {
                 Q_OBJECT
             private slots:
                 /// Tests construction of a spectrogram series
                 void testCtor_data();
                 void testCtor();
                 /// Tests merge of two spectrogram series
                 void testMerge_data();
                 void testMerge();
-                /// @todo ALX: test subdataseries
                 /// Tests get subdata of a spectrogram series
                 void testSubDataSeries_data();
                 void testSubDataSeries();
             };
             void TestSpectrogramSeries::testCtor_data()
             {
                 // x-axis data
                 QTest::addColumn<X>("xAxisData");
                 // y-axis data
                 QTest::addColumn<Y>("yAxisData");
                 // values data
                 QTest::addColumn<Values>("valuesData");
                 // construction expected to be valid
                 QTest::addColumn<bool>("expectOK");
                 // expected x-axis data (when construction is valid)
                 QTest::addColumn<X>("expectedXAxisData");
                 // expected components data (when construction is valid)
                 QTest::addColumn<Components>("expectedComponentsData");
                 QTest::newRow(
                     "invalidData (number of values by component aren't equal to the number of x-axis data)")
                     << X{1., 2., 3., 4., 5.} << Y{1., 2., 3.} << Values{1., 2., 3.} << false << X{}
                     << Components{};
                 QTest::newRow("invalidData (number of components aren't equal to the number of y-axis data)")
                     << X{1., 2., 3., 4., 5.} << Y{1., 2.} // 2 y-axis data
                     << Values{1., 2., 3., 4., 5.}         // 1 component
                     << false << X{} << Components{};
                 QTest::newRow("sortedData") << X{1., 2., 3., 4., 5.} << Y{1., 2.}              // 2 y-axis data
                                             << Values{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.} // 2 components
                                             << true << X{1., 2., 3., 4., 5.}
                                             << Components{{1., 3., 5., 7., 9.}, {2., 4., 6., 8., 10.}};
                 QTest::newRow("unsortedData") << X{5., 4., 3., 2., 1.} << Y{1., 2.}
                                               << Values{1., 2., 3., 4., 5., 6., 7., 8., 9., 10.} << true
                                               << X{1., 2., 3., 4., 5.}
                                               << Components{{9., 7., 5., 3., 1.}, {10., 8., 6., 4., 2.}};
             }
             void TestSpectrogramSeries::testCtor()
             {
                 // Creates series
                 QFETCH(X, xAxisData);
                 QFETCH(Y, yAxisData);
                 QFETCH(Values, valuesData);
                 QFETCH(bool, expectOK);
                 if (expectOK) {
                     auto series = SpectrogramBuilder{}
                                       .setX(std::move(xAxisData))
                                       .setY(std::move(yAxisData))
                                       .setValues(std::move(valuesData))
                                       .build();
                     // Validates results
                     QFETCH(X, expectedXAxisData);
                     QFETCH(Components, expectedComponentsData);
                     validateRange(series->cbegin(), series->cend(), expectedXAxisData, expectedComponentsData);
                 }
                 else {
                     QVERIFY_EXCEPTION_THROWN(SpectrogramBuilder{}
                                                  .setX(std::move(xAxisData))
                                                  .setY(std::move(yAxisData))
                                                  .setValues(std::move(valuesData))
                                                  .build(),
                                              std::invalid_argument);
                 }
             }
             void TestSpectrogramSeries::testMerge_data()
             {
                 testMerge_struct<SpectrogramSeries, Components>();
                 QTest::newRow("sortedMerge") << SpectrogramBuilder{}
                                                     .setX({1., 2., 3.})
                                                     .setY({1., 2.})
                                                     .setValues({10., 11., 20., 21., 30., 31})
                                                     .build()
                                              << SpectrogramBuilder{}
                                                     .setX({4., 5., 6.})
                                                     .setY({1., 2.})
                                                     .setValues({40., 41., 50., 51., 60., 61})
                                                     .build()
                                              << DataContainer{1., 2., 3., 4., 5., 6.}
                                              << Components{{10., 20., 30., 40., 50., 60.},
                                                            {11., 21., 31., 41., 51., 61}};
                 QTest::newRow(
                     "unsortedMerge (merge not made because the two data series have different y-axes)")
                     << SpectrogramBuilder{}
                            .setX({4., 5., 6.})
                            .setY({1., 2.})
                            .setValues({40., 41., 50., 51., 60., 61})
                            .build()
                     << SpectrogramBuilder{}
                            .setX({1., 2., 3.})
                            .setY({3., 4.})
                            .setValues({10., 11., 20., 21., 30., 31})
                            .build()
                     << DataContainer{4., 5., 6.} << Components{{40., 50., 60.}, {41., 51., 61}};
                 QTest::newRow(
                     "unsortedMerge (unsortedMerge (merge is made because the two data series have the same "
                     "y-axis)")
                     << SpectrogramBuilder{}
                            .setX({4., 5., 6.})
                            .setY({1., 2.})
                            .setValues({40., 41., 50., 51., 60., 61})
                            .build()
                     << SpectrogramBuilder{}
                            .setX({1., 2., 3.})
                            .setY({1., 2.})
                            .setValues({10., 11., 20., 21., 30., 31})
                            .build()
                     << DataContainer{1., 2., 3., 4., 5., 6.}
                     << Components{{10., 20., 30., 40., 50., 60.}, {11., 21., 31., 41., 51., 61}};
             }
             void TestSpectrogramSeries::testMerge()
             {
                 testMerge_t<SpectrogramSeries, Components>();
             }
             void TestSpectrogramSeries::testSubDataSeries_data()
             {
                 testSubDataSeries_struct<SpectrogramSeries, Components>();
                 QTest::newRow("subDataSeries (the range includes all data)")
                     << SpectrogramBuilder{}
                            .setX({1., 2., 3.})
                            .setY({1., 2.})
                            .setValues({10., 11., 20., 21., 30., 31})
                            .build()
                     << SqpRange{0., 5.} << DataContainer{1., 2., 3.}
                     << Components{{10., 20., 30.}, {11., 21., 31.}};
                 QTest::newRow("subDataSeries (the range includes no data)")
                     << SpectrogramBuilder{}
                            .setX({1., 2., 3.})
                            .setY({1., 2.})
                            .setValues({10., 11., 20., 21., 30., 31})
                            .build()
                     << SqpRange{4., 5.} << DataContainer{} << Components{{}, {}};
                 QTest::newRow("subDataSeries (the range includes some data)")
                     << SpectrogramBuilder{}
                            .setX({1., 2., 3.})
                            .setY({1., 2.})
                            .setValues({10., 11., 20., 21., 30., 31})
                            .build()
                     << SqpRange{1.1, 3} << DataContainer{2., 3.} << Components{{20., 30.}, {21., 31.}};
             }
             void TestSpectrogramSeries::testSubDataSeries()
             {
                 testSubDataSeries_t<SpectrogramSeries, Components>();
             }
             QTEST_MAIN(TestSpectrogramSeries)
             #include "TestSpectrogramSeries.moc"

gui/src/Visualization/VisualizationGraphHelper.cpp +2 -2

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Common/ColorUtils.h>
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.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); }
             };
             /**
              * Struct used to create plottables, depending on the type of the data series from which to create
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't create plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesCreator {
                 static PlottablesMap createPlottables(T &, QCustomPlot &)
                 {
                     qCCritical(LOG_DataSeries())
                         << QObject::tr("Can't create plottables: unmanaged data series type");
                     return {};
                 }
             };
             /**
              * Specialization of PlottablesCreator for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesCreator<T,
                                      typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                                or std::is_base_of<VectorSeries, T>::value> > {
                 static PlottablesMap createPlottables(T &dataSeries, QCustomPlot &plot)
                 {
                     PlottablesMap result{};
                     // Gets the number of components of the data series
                     dataSeries.lockRead();
                     auto componentCount = dataSeries.valuesData()->componentCount();
                     dataSeries.unlock();
                     auto colors = ColorUtils::colors(Qt::blue, Qt::red, componentCount);
                     // For each component of the data series, creates a QCPGraph to add to the plot
                     for (auto i = 0; i < componentCount; ++i) {
                         auto graph = plot.addGraph();
                         graph->setPen(QPen{colors.at(i)});
                         result.insert({i, graph});
                     }
                     plot.replot();
                     return result;
                 }
             };
             /**
              * Specialization of PlottablesCreator for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesCreator<T,
                                      typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
                 static PlottablesMap createPlottables(T &dataSeries, QCustomPlot &plot)
                 {
                     PlottablesMap result{};
                     result.insert({0, new QCPColorMap{plot.xAxis, plot.yAxis}});
                     plot.replot();
                     return result;
                 }
             };
             /**
              * Struct used to update plottables, depending on the type of the data series from which to update
              * them
              * @tparam T the data series' type
              * @remarks Default implementation can't update plottables
              */
             template <typename T, typename Enabled = void>
             struct PlottablesUpdater {
                 static void setPlotYAxisRange(T &, const SqpRange &, QCustomPlot &)
                 {
-                    qCCritical(LOG_DataSeries())
+                    qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't set plot y-axis range: unmanaged data series type");
                 }
                 static void updatePlottables(T &, PlottablesMap &, const SqpRange &, bool)
                 {
-                    qCCritical(LOG_DataSeries())
+                    qCCritical(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't update plottables: unmanaged data series type");
                 }
             };
             /**
              * Specialization of PlottablesUpdater for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesUpdater<T,
                                      typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                                or std::is_base_of<VectorSeries, T>::value> > {
                 static void setPlotYAxisRange(T &dataSeries, const SqpRange &xAxisRange, QCustomPlot &plot)
                 {
                     auto minValue = 0., maxValue = 0.;
                     dataSeries.lockRead();
                     auto valuesBounds = dataSeries.valuesBounds(xAxisRange.m_TStart, xAxisRange.m_TEnd);
                     auto end = dataSeries.cend();
                     if (valuesBounds.first != end && valuesBounds.second != end) {
                         auto rangeValue = [](const auto &value) { return std::isnan(value) ? 0. : value; };
                         minValue = rangeValue(valuesBounds.first->minValue());
                         maxValue = rangeValue(valuesBounds.second->maxValue());
                     }
                     dataSeries.unlock();
                     plot.yAxis->setRange(QCPRange{minValue, maxValue});
                 }
                 static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const SqpRange &range,
                                              bool rescaleAxes)
                 {
                     // For each plottable to update, resets its data
                     std::map<int, QSharedPointer<SqpDataContainer> > dataContainers{};
                     for (const auto &plottable : plottables) {
                         if (auto graph = dynamic_cast<QCPGraph *>(plottable.second)) {
                             auto dataContainer = QSharedPointer<SqpDataContainer>::create();
                             graph->setData(dataContainer);
                             dataContainers.insert({plottable.first, dataContainer});
                         }
                     }
                     dataSeries.lockRead();
                     // - Gets the data of the series included in the current range
                     // - Updates each plottable by adding, for each data item, a point that takes x-axis data
                     // and value data. The correct value is retrieved according to the index of the component
                     auto subDataIts = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);
                     for (auto it = subDataIts.first; it != subDataIts.second; ++it) {
                         for (const auto &dataContainer : dataContainers) {
                             auto componentIndex = dataContainer.first;
                             dataContainer.second->appendGraphData(
                                 QCPGraphData(it->x(), it->value(componentIndex)));
                         }
                     }
                     dataSeries.unlock();
                     if (!plottables.empty()) {
                         auto plot = plottables.begin()->second->parentPlot();
                         if (rescaleAxes) {
                             plot->rescaleAxes();
                         }
                         plot->replot();
                     }
                 }
             };
             /**
              * Specialization of PlottablesUpdater for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesUpdater<T,
                                      typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
                 static void setPlotYAxisRange(T &dataSeries, const SqpRange &xAxisRange, QCustomPlot &plot)
                 {
                     double min, max;
                     /// @todo ALX: use iterators here
                     std::tie(min, max) = dataSeries.yAxis().bounds();
                     if (!std::isnan(min) && !std::isnan(max)) {
                         plot.yAxis->setRange(QCPRange{min, max});
                     }
                 }
                 static void updatePlottables(T &dataSeries, PlottablesMap &plottables, const SqpRange &range,
                                              bool rescaleAxes)
                 {
                     if (plottables.empty()) {
                         qCDebug(LOG_VisualizationGraphHelper())
                             << QObject::tr("Can't update spectrogram: no colormap has been associated");
                         return;
                     }
                     // Gets the colormap to update (normally there is only one colormap)
                     Q_ASSERT(plottables.size() == 1);
                     auto colormap = dynamic_cast<QCPColorMap *>(plottables.at(0));
                     Q_ASSERT(colormap != nullptr);
                     dataSeries.lockRead();
                     auto its = dataSeries.xAxisRange(range.m_TStart, range.m_TEnd);
                     /// @todo ALX: use iterators here
                     auto yAxis = dataSeries.yAxis();
                     // Gets properties of x-axis and y-axis to set size and range of the colormap
                     auto nbX = std::distance(its.first, its.second);
                     auto xMin = nbX != 0 ? its.first->x() : 0.;
                     auto xMax = nbX != 0 ? (its.second - 1)->x() : 0.;
                     auto nbY = yAxis.size();
                     auto yMin = 0., yMax = 0.;
                     if (nbY != 0) {
                         std::tie(yMin, yMax) = yAxis.bounds();
                     }
                     colormap->data()->setSize(nbX, nbY);
                     colormap->data()->setRange(QCPRange{xMin, xMax}, QCPRange{yMin, yMax});
                     // Sets values
                     auto xIndex = 0;
                     for (auto it = its.first; it != its.second; ++it, ++xIndex) {
                         for (auto yIndex = 0; yIndex < nbY; ++yIndex) {
                             colormap->data()->setCell(xIndex, yIndex, it->value(yIndex));
                         }
                     }
                     dataSeries.unlock();
                     // Rescales axes
                     auto plot = colormap->parentPlot();
                     if (rescaleAxes) {
                         plot->rescaleAxes();
                     }
                     plot->replot();
                 }
             };
             /**
              * Helper used to create/update plottables
              */
             struct IPlottablesHelper {
                 virtual ~IPlottablesHelper() noexcept = default;
                 virtual PlottablesMap create(QCustomPlot &plot) const = 0;
                 virtual void setYAxisRange(const SqpRange &xAxisRange, QCustomPlot &plot) const = 0;
                 virtual void update(PlottablesMap &plottables, const SqpRange &range,
                                     bool rescaleAxes = false) const = 0;
             };
             /**
              * Default implementation of IPlottablesHelper, which takes data series to create/update plottables
              * @tparam T the data series' type
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper {
                 explicit PlottablesHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
                 PlottablesMap create(QCustomPlot &plot) const override
                 {
                     return PlottablesCreator<T>::createPlottables(m_DataSeries, plot);
                 }
                 void update(PlottablesMap &plottables, const SqpRange &range, bool rescaleAxes) const override
                 {
                     PlottablesUpdater<T>::updatePlottables(m_DataSeries, plottables, range, rescaleAxes);
                 }
                 void setYAxisRange(const SqpRange &xAxisRange, QCustomPlot &plot) const override
                 {
                     return PlottablesUpdater<T>::setPlotYAxisRange(m_DataSeries, xAxisRange, plot);
                 }
                 T &m_DataSeries;
             };
             /// Creates IPlottablesHelper according to a data series
             std::unique_ptr<IPlottablesHelper> createHelper(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
                     return std::make_unique<PlottablesHelper<ScalarSeries> >(*scalarSeries);
                 }
                 else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
                     return std::make_unique<PlottablesHelper<SpectrogramSeries> >(*spectrogramSeries);
                 }
                 else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
                     return std::make_unique<PlottablesHelper<VectorSeries> >(*vectorSeries);
                 }
                 else {
                     return std::make_unique<PlottablesHelper<IDataSeries> >(*dataSeries);
                 }
             }
             } // namespace
             PlottablesMap VisualizationGraphHelper::create(std::shared_ptr<Variable> variable,
                                                            QCustomPlot &plot) noexcept
             {
                 if (variable) {
                     auto helper = createHelper(variable->dataSeries());
                     auto plottables = helper->create(plot);
                     return plottables;
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't create graph plottables : the variable is null");
                     return PlottablesMap{};
                 }
             }
             void VisualizationGraphHelper::setYAxisRange(std::shared_ptr<Variable> variable,
                                                          QCustomPlot &plot) noexcept
             {
                 if (variable) {
                     auto helper = createHelper(variable->dataSeries());
                     helper->setYAxisRange(variable->range(), plot);
                 }
                 else {
                     qCDebug(LOG_VisualizationGraphHelper())
                         << QObject::tr("Can't set y-axis range of plot: the variable is null");
                 }
             }
             void VisualizationGraphHelper::updateData(PlottablesMap &plottables,
                                                       std::shared_ptr<IDataSeries> dataSeries,
                                                       const SqpRange &dateTime)
             {
                 auto helper = createHelper(dataSeries);
                 helper->update(plottables, dateTime);
             }

gui/src/Visualization/VisualizationGraphWidget.cpp 0 -1

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationDefs.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Common/MimeTypesDef.h>
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <DragAndDrop/DragDropHelper.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 explicit VisualizationGraphWidgetPrivate(const QString &name)
                         : m_Name{name},
                           m_DoAcquisition{true},
                           m_IsCalibration{false},
                           m_RenderingDelegate{nullptr}
                 {
                 }
                 QString m_Name;
                 // 1 variable -> n qcpplot
                 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
                 bool m_DoAcquisition;
                 bool m_IsCalibration;
-                QCPItemTracer *m_TextTracer;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : VisualizationDragWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectItems);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 // The delegate must be initialized after the ui as it uses the plot
                 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*this);
                 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
                 connect(ui->widget, &QCustomPlot::mouseRelease, this,
                         &VisualizationGraphWidget::onMouseRelease);
                 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
                                                &QCPAxis::rangeChanged),
                         this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
                 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
                         &VariableController::onRequestDataLoading);
                 connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this,
                         &VisualizationGraphWidget::onUpdateVarDisplaying);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             VisualizationZoneWidget *VisualizationGraphWidget::parentZoneWidget() const noexcept
             {
                 auto parent = parentWidget();
                 while (parent != nullptr && !qobject_cast<VisualizationZoneWidget *>(parent)) {
                     parent = parent->parentWidget();
                 }
                 return qobject_cast<VisualizationZoneWidget *>(parent);
             }
             void VisualizationGraphWidget::enableAcquisition(bool enable)
             {
                 impl->m_DoAcquisition = enable;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
                 // Set axes properties according to the units of the data series
                 /// @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 xAxisUnit = Unit{};
                 auto valuesUnit = Unit{};
                 if (auto dataSeries = variable->dataSeries()) {
                     dataSeries->lockRead();
                     xAxisUnit = dataSeries->xAxisUnit();
                     valuesUnit = dataSeries->valuesUnit();
                     dataSeries->unlock();
                 }
                 impl->m_RenderingDelegate->setAxesProperties(xAxisUnit, valuesUnit);
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
                 this->enableAcquisition(false);
                 this->setGraphRange(range);
                 this->enableAcquisition(true);
                 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, false);
                 emit variableAdded(variable);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
                 auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);
                 if (variableIt != impl->m_VariableToPlotMultiMap.cend()) {
                     emit variableAboutToBeRemoved(variable);
                     auto &plottablesMap = variableIt->second;
                     for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
                          plottableIt != plottableEnd;) {
                         ui->widget->removePlottable(plottableIt->second);
                         plottableIt = plottablesMap.erase(plottableIt);
                     }
                     impl->m_VariableToPlotMultiMap.erase(variableIt);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             QList<std::shared_ptr<Variable> > VisualizationGraphWidget::variables() const
             {
                 auto variables = QList<std::shared_ptr<Variable> >{};
                 for (auto it = std::cbegin(impl->m_VariableToPlotMultiMap);
                      it != std::cend(impl->m_VariableToPlotMultiMap); ++it) {
                     variables << it->first;
                 }
                 return variables;
             }
             void VisualizationGraphWidget::setYRange(std::shared_ptr<Variable> variable)
             {
                 if (!variable) {
                     qCCritical(LOG_VisualizationGraphWidget()) << "Can't set y-axis range: variable is null";
                     return;
                 }
                 VisualizationGraphHelper::setYAxisRange(variable, *ui->widget);
             }
             SqpRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto graphRange = ui->widget->xAxis->range();
                 return SqpRange{graphRange.lower, graphRange.upper};
             }
             void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visit(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationGraphWidget::canDrop(const Variable &variable) const
             {
                 /// @todo : for the moment, a graph can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationGraphWidget::contains(const Variable &variable) const
             {
                 // Finds the variable among the keys of the map
                 auto variablePtr = &variable;
                 auto findVariable
                     = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
                 auto end = impl->m_VariableToPlotMultiMap.cend();
                 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
                 return it != end;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return impl->m_Name;
             }
             QMimeData *VisualizationGraphWidget::mimeData() const
             {
                 auto mimeData = new QMimeData;
                 mimeData->setData(MIME_TYPE_GRAPH, QByteArray{});
                 auto timeRangeData = TimeController::mimeDataForTimeRange(graphRange());
                 mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                 return mimeData;
             }
             bool VisualizationGraphWidget::isDragAllowed() const
             {
                 return true;
             }
             void VisualizationGraphWidget::highlightForMerge(bool highlighted)
             {
                 if (highlighted) {
                     plot().setBackground(QBrush(QColor("#BBD5EE")));
                 }
                 else {
                     plot().setBackground(QBrush(Qt::white));
                 }
                 plot().update();
             }
             void VisualizationGraphWidget::closeEvent(QCloseEvent *event)
             {
                 Q_UNUSED(event);
                 // Prevents that all variables will be removed from graph when it will be closed
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
                     emit variableAboutToBeRemoved(variableEntry.first);
                 }
             }
             void VisualizationGraphWidget::enterEvent(QEvent *event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(true);
             }
             void VisualizationGraphWidget::leaveEvent(QEvent *event)
             {
                 Q_UNUSED(event);
                 impl->m_RenderingDelegate->showGraphOverlay(false);
             }
             QCustomPlot &VisualizationGraphWidget::plot() noexcept
             {
                 return *ui->widget;
             }
             void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
             {
                 QMenu graphMenu{};
                 // Iterates on variables (unique keys)
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
                           end = impl->m_VariableToPlotMultiMap.cend();
                      it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                     // 'Remove variable' action
                     graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
                                         [ this, var = it->first ]() { removeVariable(var); });
                 }
                 if (!graphMenu.isEmpty()) {
                     graphMenu.exec(QCursor::pos());
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
                                                         << QThread::currentThread()->objectName() << "DoAcqui"
                                                         << impl->m_DoAcquisition;
                 auto graphRange = SqpRange{t1.lower, t1.upper};
                 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
                 if (impl->m_DoAcquisition) {
                     QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
                     for (auto it = impl->m_VariableToPlotMultiMap.begin(),
                               end = impl->m_VariableToPlotMultiMap.end();
                          it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                         variableUnderGraphVector.push_back(it->first);
                     }
                     emit requestDataLoading(std::move(variableUnderGraphVector), graphRange,
                                             !impl->m_IsCalibration);
                     if (!impl->m_IsCalibration) {
                         qCDebug(LOG_VisualizationGraphWidget())
                             << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
                             << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
                         emit synchronize(graphRange, oldGraphRange);
                     }
                 }
             }
             void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->onMouseMove(event);
                 VisualizationDragWidget::mouseMoveEvent(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
                 // Lambda that enables a zoom orientation if the key modifier related to this orientation
                 // has
                 // been pressed
                 auto enableOrientation
                     = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                           auto orientationEnabled = event->modifiers().testFlag(modifier);
                           zoomOrientations.setFlag(orientation, orientationEnabled);
                       };
                 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
                 plot().setInteraction(QCP::iRangeDrag, !event->modifiers().testFlag(Qt::AltModifier));
                 VisualizationDragWidget::mousePressEvent(event);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = false;
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 auto graphRange = ui->widget->xAxis->range();
                 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
                     auto variable = variableEntry.first;
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
                     if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
                         VisualizationGraphHelper::updateData(variableEntry.second, variable->dataSeries(),
                                                              variable->range());
                     }
                 }
             }
             void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
                                                                  const SqpRange &range)
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end()) {
                     VisualizationGraphHelper::updateData(it->second, variable->dataSeries(), range);
                 }
             }

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