GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r636:ad1efe843595

Add thread protection for DataSeries...

perrinel -

r636:ad1efe843595

parent child

Context file:

r636:ad1efe843595

core/src/Variable/VariableModel.cpp +4 -1

             #include <Variable/Variable.h>
             #include <Variable/VariableModel.h>
             #include <Common/DateUtils.h>
             #include <Data/IDataSeries.h>
             #include <QSize>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableModel, "VariableModel")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             const auto TSTART_COLUMN = 1;
             const auto TEND_COLUMN = 2;
             const auto UNIT_COLUMN = 3;
             const auto MISSION_COLUMN = 4;
             const auto PLUGIN_COLUMN = 5;
             const auto NB_COLUMNS = 6;
             // Column properties
             const auto DEFAULT_HEIGHT = 25;
             const auto DEFAULT_WIDTH = 100;
             struct ColumnProperties {
                 ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
                                  int height = DEFAULT_HEIGHT)
                         : m_Name{name}, m_Width{width}, m_Height{height}
                 {
                 }
                 QString m_Name;
                 int m_Width;
                 int m_Height;
             };
             const auto COLUMN_PROPERTIES = QHash<int, ColumnProperties>{
                 {NAME_COLUMN, {QObject::tr("Name")}},       {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
                 {TEND_COLUMN, {QObject::tr("tEnd"), 180}},  {UNIT_COLUMN, {QObject::tr("Unit")}},
                 {MISSION_COLUMN, {QObject::tr("Mission")}}, {PLUGIN_COLUMN, {QObject::tr("Plugin")}}};
             /// Format for datetimes
             const auto DATETIME_FORMAT = QStringLiteral("dd/MM/yyyy \nhh:mm:ss:zzz");
             } // namespace
             struct VariableModel::VariableModelPrivate {
                 /// Variables created in SciQlop
                 std::vector<std::shared_ptr<Variable> > m_Variables;
                 std::unordered_map<std::shared_ptr<Variable>, double> m_VariableToProgress;
                 /// Return the row index of the variable. -1 if it's not found
                 int indexOfVariable(Variable *variable) const noexcept;
             };
             VariableModel::VariableModel(QObject *parent)
                     : QAbstractTableModel{parent}, impl{spimpl::make_unique_impl<VariableModelPrivate>()}
             {
             }
             std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
                                                                     const SqpRange &dateTime,
                                                                     const QVariantHash &metadata) noexcept
             {
                 auto insertIndex = rowCount();
                 beginInsertRows({}, insertIndex, insertIndex);
                 auto variable = std::make_shared<Variable>(name, dateTime, metadata);
                 impl->m_Variables.push_back(variable);
                 connect(variable.get(), &Variable::updated, this, &VariableModel::onVariableUpdated);
                 endInsertRows();
                 return variable;
             }
             void VariableModel::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_Variable()) << "Can't delete a null variable from the model";
                     return;
                 }
                 // Finds variable in the model
                 auto begin = impl->m_Variables.cbegin();
                 auto end = impl->m_Variables.cend();
                 auto it = std::find(begin, end, variable);
                 if (it != end) {
                     auto removeIndex = std::distance(begin, it);
                     // Deletes variable
                     beginRemoveRows({}, removeIndex, removeIndex);
                     impl->m_Variables.erase(it);
                     endRemoveRows();
                 }
                 else {
                     qCritical(LOG_VariableModel())
                         << tr("Can't delete variable %1 from the model: the variable is not in the model")
                                .arg(variable->name());
                 }
                 // Removes variable from progress map
                 impl->m_VariableToProgress.erase(variable);
             }
             std::shared_ptr<Variable> VariableModel::variable(int index) const
             {
                 return (index >= 0 && index < impl->m_Variables.size()) ? impl->m_Variables[index] : nullptr;
             }
             void VariableModel::setDataProgress(std::shared_ptr<Variable> variable, double progress)
             {
                 if (progress > 0.0) {
                     impl->m_VariableToProgress[variable] = progress;
                 }
                 else {
                     impl->m_VariableToProgress.erase(variable);
                 }
                 auto modelIndex = createIndex(impl->indexOfVariable(variable.get()), NAME_COLUMN);
                 emit dataChanged(modelIndex, modelIndex);
             }
             int VariableModel::columnCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return NB_COLUMNS;
             }
             int VariableModel::rowCount(const QModelIndex &parent) const
             {
                 Q_UNUSED(parent);
                 return impl->m_Variables.size();
             }
             QVariant VariableModel::data(const QModelIndex &index, int role) const
             {
                 if (!index.isValid()) {
                     return QVariant{};
                 }
                 if (index.row() < 0 || index.row() >= rowCount()) {
                     return QVariant{};
                 }
                 if (role == Qt::DisplayRole) {
                     if (auto variable = impl->m_Variables.at(index.row()).get()) {
                         /// Lambda function that builds the variant to return for a time value
                         /// @param getValueFun function used to get for a data series the iterator on the entry
                         /// that contains the time value to display
                         auto dateTimeVariant = [variable](const auto &getValueFun) {
                             if (auto dataSeries = variable->dataSeries()) {
+                                dataSeries->lockRead();
                                 auto it = getValueFun(*dataSeries);
-                                return (it != dataSeries->cend())
+                                auto resVariant = (it != dataSeries->cend())
                                            ? DateUtils::dateTime(it->x()).toString(DATETIME_FORMAT)
                                            : QVariant{};
+                                dataSeries->unlock();
+                                return resVariant;
                             }
                             else {
                                 return QVariant{};
                             }
                         };
                         switch (index.column()) {
                             case NAME_COLUMN:
                                 return variable->name();
                             case TSTART_COLUMN:
                                 // Shows the min value of the data series above the range tstart
                                 return dateTimeVariant([min = variable->range().m_TStart](
                                     const auto &dataSeries) { return dataSeries.minXAxisData(min); });
                             case TEND_COLUMN:
                                 // Shows the max value of the data series under the range tend
                                 return dateTimeVariant([max = variable->range().m_TEnd](
                                     const auto &dataSeries) { return dataSeries.maxXAxisData(max); });
                             case UNIT_COLUMN:
                                 return variable->metadata().value(QStringLiteral("units"));
                             case MISSION_COLUMN:
                                 return variable->metadata().value(QStringLiteral("mission"));
                             case PLUGIN_COLUMN:
                                 return variable->metadata().value(QStringLiteral("plugin"));
                             default:
                                 // No action
                                 break;
                         }
                         qWarning(LOG_VariableModel())
                             << tr("Can't get data (unknown column %1)").arg(index.column());
                     }
                     else {
                         qWarning(LOG_VariableModel()) << tr("Can't get data (no variable)");
                     }
                 }
                 else if (role == VariableRoles::ProgressRole) {
                     if (auto variable = impl->m_Variables.at(index.row())) {
                         auto it = impl->m_VariableToProgress.find(variable);
                         if (it != impl->m_VariableToProgress.cend()) {
                             return it->second;
                         }
                     }
                 }
                 return QVariant{};
             }
             QVariant VariableModel::headerData(int section, Qt::Orientation orientation, int role) const
             {
                 if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
                     return QVariant{};
                 }
                 if (orientation == Qt::Horizontal) {
                     auto propertiesIt = COLUMN_PROPERTIES.find(section);
                     if (propertiesIt != COLUMN_PROPERTIES.cend()) {
                         // Role is either DisplayRole or SizeHintRole
                         return (role == Qt::DisplayRole)
                                    ? QVariant{propertiesIt->m_Name}
                                    : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
                     }
                     else {
                         qWarning(LOG_VariableModel())
                             << tr("Can't get header data (unknown column %1)").arg(section);
                     }
                 }
                 return QVariant{};
             }
             void VariableModel::abortProgress(const QModelIndex &index)
             {
                 if (auto variable = impl->m_Variables.at(index.row())) {
                     emit abortProgessRequested(variable);
                 }
             }
             void VariableModel::onVariableUpdated() noexcept
             {
                 // Finds variable that has been updated in the model
                 if (auto updatedVariable = dynamic_cast<Variable *>(sender())) {
                     auto updatedVariableIndex = impl->indexOfVariable(updatedVariable);
                     if (updatedVariableIndex > -1) {
                         emit dataChanged(createIndex(updatedVariableIndex, 0),
                                          createIndex(updatedVariableIndex, columnCount() - 1));
                     }
                 }
             }
             int VariableModel::VariableModelPrivate::indexOfVariable(Variable *variable) const noexcept
             {
                 auto begin = std::cbegin(m_Variables);
                 auto end = std::cend(m_Variables);
                 auto it
                     = std::find_if(begin, end, [variable](const auto &var) { return var.get() == variable; });
                 if (it != end) {
                     // Gets the index of the variable in the model: we assume here that views have the same
                     // order as the model
                     return std::distance(begin, it);
                 }
                 else {
                     return -1;
                 }
             }

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

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/qcustomplot.h"
             #include <Common/ColorUtils.h>
             #include <Data/ScalarSeries.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); }
             };
             /// 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();
                 }
             }
-            /// Sets axes properties according to the properties of a data series
+            /// Sets axes properties according to the properties of a data series. Not thread safe
             template <int Dim>
             void setAxesProperties(const DataSeries<Dim> &dataSeries, QCustomPlot &plot) noexcept
             {
                 /// @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, dataSeries.xAxisUnit());
                 setAxisProperties(plot.yAxis, dataSeries.valuesUnit());
             }
             /**
              * 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});
                     }
                     // Axes properties
+                    dataSeries.lockRead();
                     setAxesProperties(dataSeries, plot);
+                    dataSeries.unlock();
                     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 updatePlottables(T &, PlottablesMap &, const SqpRange &, bool)
                 {
                     qCCritical(LOG_DataSeries())
                         << 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 updatePlottables(T &dataSeries, PlottablesMap &plottables, const SqpRange &range,
                                              bool rescaleAxes)
                 {
-                    dataSeries.lockRead();
                     // 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();
                     }
                 }
             };
             /**
              * Helper used to create/update plottables
              */
             struct IPlottablesHelper {
                 virtual ~IPlottablesHelper() noexcept = default;
                 virtual PlottablesMap create(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);
                 }
                 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 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::updateData(PlottablesMap &plottables,
                                                       std::shared_ptr<IDataSeries> dataSeries,
                                                       const SqpRange &dateTime)
             {
                 auto helper = createHelper(dataSeries);
                 helper->update(plottables, dateTime);
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +3 -1

             #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>
             #include <cmath>
             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;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::ZoomOut: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                                     auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
                                                                            << deltaLeft;
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
                                                                            << deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     graphChildRange.m_TStart -= deltaLeft;
                                     graphChildRange.m_TEnd += deltaRight;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanRight: {
                                     qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
                                     auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                                     graphChildRange.m_TStart += deltaRight;
                                     graphChildRange.m_TEnd += deltaRight;
                                     qCDebug(LOG_VisualizationZoneWidget())
                                         << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                                     break;
                                 }
                                 case AcquisitionZoomType::PanLeft: {
                                     qCDebug(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: {
                                     qCDebug(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);
                             qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
                                                                    << graphChild->graphRange();
                             qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
                                                                    << graphChildRange;
                             qCDebug(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);
                 // get y using variable range
                 if (auto dataSeries = variable->dataSeries()) {
-                    auto valuesBounds = dataSeries->valuesBounds(range.m_TStart, range.m_TEnd);
+                    dataSeries->lockRead();
+                    auto valuesBounds = dataSeries->valuesBounds(variable->range().m_TStart, variable->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});
                     }
+                    dataSeries->unlock();
                 }
                 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/mockplugin/src/CosinusProvider.cpp +1 -1

             #include "CosinusProvider.h"
             #include <Data/DataProviderParameters.h>
             #include <Data/ScalarSeries.h>
             #include <cmath>
             #include <QFuture>
             #include <QThread>
             #include <QtConcurrent/QtConcurrent>
             Q_LOGGING_CATEGORY(LOG_CosinusProvider, "CosinusProvider")
             std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
                                                                        const SqpRange &dataRangeRequested)
             {
                 // TODO: Add Mutex
                 auto dataIndex = 0;
                 // Gets the timerange from the parameters
-                double freq = 100.0;
+                double freq = 1.0;
                 double start = std::ceil(dataRangeRequested.m_TStart * freq); // 100 htz
                 double end = std::floor(dataRangeRequested.m_TEnd * freq);    // 100 htz
                 // We assure that timerange is valid
                 if (end < start) {
                     std::swap(start, end);
                 }
                 // Generates scalar series containing cosinus values (one value per second)
                 auto dataCount = end - start;
                 auto xAxisData = QVector<double>{};
                 xAxisData.resize(dataCount);
                 auto valuesData = QVector<double>{};
                 valuesData.resize(dataCount);
                 int progress = 0;
                 auto progressEnd = dataCount;
                 for (auto time = start; time < end; ++time, ++dataIndex) {
                     auto it = m_VariableToEnableProvider.find(acqIdentifier);
                     if (it != m_VariableToEnableProvider.end() && it.value()) {
                         const auto timeOnFreq = time / freq;
                         xAxisData.replace(dataIndex, timeOnFreq);
                         valuesData.replace(dataIndex, std::cos(timeOnFreq));
                         // progression
                         int currentProgress = (time - start) * 100.0 / progressEnd;
                         if (currentProgress != progress) {
                             progress = currentProgress;
                             emit dataProvidedProgress(acqIdentifier, progress);
                         }
                     }
                     else {
                         if (!it.value()) {
                             qCDebug(LOG_CosinusProvider())
                                 << "CosinusProvider::retrieveData: ARRET De l'acquisition detecté"
                                 << end - time;
                         }
                     }
                 }
                 emit dataProvidedProgress(acqIdentifier, 0.0);
                 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                       Unit{QStringLiteral("t"), true}, Unit{});
             }
             void CosinusProvider::requestDataLoading(QUuid acqIdentifier,
                                                      const DataProviderParameters &parameters)
             {
                 // TODO: Add Mutex
                 m_VariableToEnableProvider[acqIdentifier] = true;
                 qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::requestDataLoading"
                                                << QThread::currentThread()->objectName();
                 // NOTE: Try to use multithread if possible
                 const auto times = parameters.m_Times;
                 for (const auto &dateTime : qAsConst(times)) {
                     if (m_VariableToEnableProvider[acqIdentifier]) {
                         auto scalarSeries = this->retrieveData(acqIdentifier, dateTime);
                         qCDebug(LOG_CosinusProvider()) << "TORM: CosinusProvider::dataProvided";
                         emit dataProvided(acqIdentifier, scalarSeries, dateTime);
                     }
                 }
             }
             void CosinusProvider::requestDataAborting(QUuid acqIdentifier)
             {
                 // TODO: Add Mutex
                 qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataAborting" << acqIdentifier
                                                << QThread::currentThread()->objectName();
                 auto it = m_VariableToEnableProvider.find(acqIdentifier);
                 if (it != m_VariableToEnableProvider.end()) {
                     it.value() = false;
                 }
                 else {
                     qCWarning(LOG_CosinusProvider())
                         << tr("Aborting progression of inexistant identifier detected !!!");
                 }
             }

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