HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r582:dd4269fbedea

1

#include "Visualization/VisualizationGraphWidget.h"

1

#include "Visualization/VisualizationGraphWidget.h"

2

#include "Visualization/IVisualizationWidgetVisitor.h"

2

#include "Visualization/IVisualizationWidgetVisitor.h"

3

#include "Visualization/VisualizationDefs.h"

3

#include "Visualization/VisualizationGraphHelper.h"

4

#include "Visualization/VisualizationGraphHelper.h"

4

#include "Visualization/VisualizationGraphRenderingDelegate.h"

5

#include "Visualization/VisualizationGraphRenderingDelegate.h"

5

#include "ui_VisualizationGraphWidget.h"

6

#include "ui_VisualizationGraphWidget.h"

33

}

34

}

34

35

// 1 variable -> n qcpplot

36

// 1 variable -> n qcpplot

36

std::~~multi~~map<std::shared_ptr<Variable>, ~~QCPAbstract~~Plottable *> m_VariableToPlotMultiMap;

37

std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;

37

bool m_DoAcquisition;

38

bool m_DoAcquisition;

38

bool m_IsCalibration;

39

bool m_IsCalibration;

39

QCPItemTracer *m_TextTracer;

40

QCPItemTracer *m_TextTracer;

99

void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)

100

void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)

100

{

101

{

101

// Uses delegate to create the qcpplot components according to the variable

102

// Uses delegate to create the qcpplot components according to the variable

102

auto createdPlottables = VisualizationGraphHelper::createV2(variable, *ui->widget);

103

auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);

103

104

impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});

104

for (auto createdPlottable : qAsConst(createdPlottables)) {

105

impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});

106

}

107

105

108

connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));

106

connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));

109

107

124

// Each component associated to the variable :

122

// Each component associated to the variable :

125

// - is removed from qcpplot (which deletes it)

123

// - is removed from qcpplot (which deletes it)

126

// - is no longer referenced in the map

124

// - is no longer referenced in the map

127

auto ~~components~~It = impl->m_VariableToPlotMultiMap.~~equal_range~~(variable);

125

auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);

128

for (auto it = componentsIt.first; it != componentsIt.second;) {

126

if (variableIt != impl->m_VariableToPlotMultiMap.cend()) {

129

ui->~~widget~~->~~removePlottable~~(it->second);

127

auto &plottablesMap = variableIt->second;

130

it = impl->m_VariableToPlotMultiMap.erase(it);

128

129

for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();

130

plottableIt != plottableEnd;) {

131

ui->widget->removePlottable(plottableIt->second);

132

plottableIt = plottablesMap.erase(plottableIt);

133

}

134

135

impl->m_VariableToPlotMultiMap.erase(variableIt);

131

}

136

}

132

137

133

// Updates graph

138

// Updates graph

282

287

283

void VisualizationGraphWidget::onDataCacheVariableUpdated()

288

void VisualizationGraphWidget::onDataCacheVariableUpdated()

284

{

289

{

285

// NOTE:

286

// We don't want to call the method for each component of a variable unitarily, but for

287

// all

288

// its components at once (eg its three components in the case of a vector).

289

290

// The unordered_multimap does not do this easily, so the question is whether to:

291

// - use an ordered_multimap and the algos of std to group the values by key

292

// - use a map (unique keys) and store as values directly the list of components

293

294

auto graphRange = ui->widget->xAxis->range();

290

auto graphRange = ui->widget->xAxis->range();

295

auto dateTime = SqpRange{graphRange.lower, graphRange.upper};

291

auto dateTime = SqpRange{graphRange.lower, graphRange.upper};

296

292

297

for (auto it = impl->m_VariableToPlotMultiMap.~~cbegin~~();

293

for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {

298

it != impl->m_VariableToPlotMultiMap.cend(); ++it) {

294

auto variable = variableEntry.first;

299

auto variable = it->first;

300

qCDebug(LOG_VisualizationGraphWidget())

295

qCDebug(LOG_VisualizationGraphWidget())

301

<< "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();

296

<< "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();

302

qCDebug(LOG_VisualizationGraphWidget())

297

qCDebug(LOG_VisualizationGraphWidget())

303

<< "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;

298

<< "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;

304

if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {

299

if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {

305

300

VisualizationGraphHelper::updateData(variableEntry.second, variable->dataSeries().get(),

306

VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,

301

variable->range());

307

variable->dataSeries(), variable->range());

308

}

302

}

309

}

303

}

310

}

304

}

312

void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,

306

void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,

313

const SqpRange &range)

307

const SqpRange &range)

314

{

308

{

315

auto ~~componentsI~~t = impl->m_VariableToPlotMultiMap.~~equal_range~~(variable);

309

auto it = impl->m_VariableToPlotMultiMap.find(variable);

316

for (auto it = componentsIt.first; it != componentsIt.second;) {

310

if (it != impl->m_VariableToPlotMultiMap.end()) {

317

VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,

311

VisualizationGraphHelper::updateData(it->second, variable->dataSeries().get(), range);

318

variable->dataSeries(), range);

319

}

312

}

320

}

313

}

	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

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
+            #include "Visualization/VisualizationDefs.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "ui_VisualizationGraphWidget.h"
                 }
                 // 1 variable -> n qcpplot
-                std::multimap<std::shared_ptr<Variable>, QCPAbstractPlottable *> m_VariableToPlotMultiMap;
+                std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
                 bool m_DoAcquisition;
                 bool m_IsCalibration;
                 QCPItemTracer *m_TextTracer;
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
             {
                 // Uses delegate to create the qcpplot components according to the variable
-                auto createdPlottables = VisualizationGraphHelper::createV2(variable, *ui->widget);
+                auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
+                impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
-                for (auto createdPlottable : qAsConst(createdPlottables)) {
-                    impl->m_VariableToPlotMultiMap.insert({variable, createdPlottable});
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
-                auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
+                auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);
-                for (auto it = componentsIt.first; it != componentsIt.second;) {
+                if (variableIt != impl->m_VariableToPlotMultiMap.cend()) {
-                    ui->widget->removePlottable(it->second);
+                    auto &plottablesMap = variableIt->second;
-                    it = impl->m_VariableToPlotMultiMap.erase(it);
+                    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
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
-                // NOTE:
-                //    We don't want to call the method for each component of a variable unitarily, but for
-                //    all
-                //    its components at once (eg its three components in the case of a vector).
-                //    The unordered_multimap does not do this easily, so the question is whether to:
-                //    - use an ordered_multimap and the algos of std to group the values by key
-                //    - use a map (unique keys) and store as values directly the list of components
                 auto graphRange = ui->widget->xAxis->range();
                 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
-                for (auto it = impl->m_VariableToPlotMultiMap.cbegin();
+                for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
-                     it != impl->m_VariableToPlotMultiMap.cend(); ++it) {
+                    auto variable = variableEntry.first;
-                    auto variable = it->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().get(),
-                        VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
+                                                             variable->range());
-                                                             variable->dataSeries(), variable->range());
                     }
                 }
             }
             void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
                                                                  const SqpRange &range)
             {
-                auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
+                auto it = impl->m_VariableToPlotMultiMap.find(variable);
-                for (auto it = componentsIt.first; it != componentsIt.second;) {
+                if (it != impl->m_VariableToPlotMultiMap.end()) {
-                    VisualizationGraphHelper::updateData(QVector<QCPAbstractPlottable *>{} << it->second,
+                    VisualizationGraphHelper::updateData(it->second, variable->dataSeries().get(), range);
-                                                         variable->dataSeries(), range);
                 }
             }