LinechartWidget.cc 33 KB
Newer Older
1 2 3 4 5 6 7 8
/****************************************************************************
 *
 *   (c) 2009-2016 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
 *
 * QGroundControl is licensed according to the terms in the file
 * COPYING.md in the root of the source code directory.
 *
 ****************************************************************************/
pixhawk's avatar
pixhawk committed
9 10 11 12 13 14 15


/**
 * @file
 *   @brief Line chart plot widget
 *
 *   @author Lorenz Meier <mavteam@student.ethz.ch>
16
 *   @author Thomas Gubler <thomasgubler@student.ethz.ch>
pixhawk's avatar
pixhawk committed
17 18 19 20 21 22 23 24
 */

#include <QDebug>
#include <QWidget>
#include <QHBoxLayout>
#include <QGridLayout>
#include <QComboBox>
#include <QToolButton>
25
#include <QSizePolicy>
pixhawk's avatar
pixhawk committed
26 27 28 29 30 31
#include <QScrollBar>
#include <QLabel>
#include <QMenu>
#include <QSpinBox>
#include <QColor>
#include <QPalette>
32
#include <QStandardPaths>
33
#include <QShortcut>
pixhawk's avatar
pixhawk committed
34 35 36 37

#include "LinechartWidget.h"
#include "LinechartPlot.h"
#include "LogCompressor.h"
lm's avatar
lm committed
38
#include "QGC.h"
pixhawk's avatar
pixhawk committed
39
#include "MG.h"
Don Gagne's avatar
Don Gagne committed
40
#include "QGCFileDialog.h"
Don Gagne's avatar
Don Gagne committed
41
#include "QGCMessageBox.h"
42
#include "QGCApplication.h"
43
#include "SettingsManager.h"
pixhawk's avatar
pixhawk committed
44

45
LinechartWidget::LinechartWidget(int systemid, QWidget *parent) : QWidget(parent),
46 47 48 49 50 51 52 53 54 55 56 57 58 59
    sysid(systemid),
    activePlot(NULL),
    curvesLock(new QReadWriteLock()),
    plotWindowLock(),
    curveListIndex(0),
    curveListCounter(0),
    curveLabels(new QMap<QString, QLabel*>()),
    curveMeans(new QMap<QString, QLabel*>()),
    curveMedians(new QMap<QString, QLabel*>()),
    curveVariances(new QMap<QString, QLabel*>()),
    logFile(new QFile()),
    logindex(1),
    logging(false),
    logStartTime(0),
lm's avatar
lm committed
60
    updateTimer(new QTimer()),
61 62
    selectedMAV(-1),
    lastTimestamp(0)
pixhawk's avatar
pixhawk committed
63 64 65
{
    // Add elements defined in Qt Designer
    ui.setupUi(this);
Gus Grubba's avatar
Gus Grubba committed
66
    this->setMinimumSize(600, 400);
pixhawk's avatar
pixhawk committed
67 68 69 70

    // Add and customize curve list elements (left side)
    curvesWidget = new QWidget(ui.curveListWidget);
    ui.curveListWidget->setWidget(curvesWidget);
71
    curvesWidgetLayout = new QGridLayout(curvesWidget);
Gus Grubba's avatar
Gus Grubba committed
72 73
    curvesWidgetLayout->setMargin(6);
    curvesWidgetLayout->setSpacing(6);
74
    curvesWidgetLayout->setAlignment(Qt::AlignTop);
Gus Grubba's avatar
Gus Grubba committed
75
    curvesWidgetLayout->setColumnMinimumWidth(0, 10);
76 77

    curvesWidgetLayout->setColumnStretch(0, 0);
Gus Grubba's avatar
Gus Grubba committed
78
    curvesWidgetLayout->setColumnStretch(1, 10);
79 80 81 82
    curvesWidgetLayout->setColumnStretch(2, 80);
    curvesWidgetLayout->setColumnStretch(3, 50);
    curvesWidgetLayout->setColumnStretch(4, 50);
    curvesWidgetLayout->setColumnStretch(5, 50);
83
    curvesWidgetLayout->setColumnStretch(6, 50);
84

pixhawk's avatar
pixhawk committed
85 86
    curvesWidget->setLayout(curvesWidgetLayout);

87
    // Create curve list headings
88 89 90 91 92 93
    connect(ui.recolorButton, &QPushButton::clicked, this, &LinechartWidget::recolor);
    connect(ui.shortNameCheckBox, &QCheckBox::clicked, this, &LinechartWidget::setShortNames);
    connect(ui.plotFilterLineEdit, &QLineEdit::textChanged, this, &LinechartWidget::filterCurves);
    QShortcut *shortcut  = new QShortcut(this);
    shortcut->setKey(QKeySequence(Qt::CTRL + Qt::Key_F));
    connect(shortcut, &QShortcut::activated, this, &LinechartWidget::setPlotFilterLineEditFocus);
94

95 96
    int labelRow = curvesWidgetLayout->rowCount();

Gus Grubba's avatar
Gus Grubba committed
97
    selectAllCheckBox = new QCheckBox(this);
98
    connect(selectAllCheckBox, &QCheckBox::clicked, this, &LinechartWidget::selectAllCurves);
Gus Grubba's avatar
Gus Grubba committed
99
    curvesWidgetLayout->addWidget(selectAllCheckBox, labelRow, 0);
100

Gus Grubba's avatar
Gus Grubba committed
101 102 103 104
    QWidget* colorIcon = new QWidget(this);
    colorIcon->setMinimumSize(QSize(5, 14));
    colorIcon->setMaximumSize(QSize(5, 14));
    curvesWidgetLayout->addWidget(colorIcon, labelRow, 1);
105

Gus Grubba's avatar
Gus Grubba committed
106 107
    curvesWidgetLayout->addWidget(new QLabel(tr("Name")),     labelRow, 2);
    curvesWidgetLayout->addWidget(new QLabel(tr("Val")),      labelRow, 3, Qt::AlignRight);
108

Gus Grubba's avatar
Gus Grubba committed
109 110
    QLabel* pUnit = new QLabel(tr("Unit"));
    curvesWidgetLayout->addWidget(pUnit,                      labelRow, 4);
111

Gus Grubba's avatar
Gus Grubba committed
112 113
    curvesWidgetLayout->addWidget(new QLabel(tr("Mean")),     labelRow, 5, Qt::AlignRight);
    curvesWidgetLayout->addWidget(new QLabel(tr("Variance")), labelRow, 6, Qt::AlignRight);
114 115


pixhawk's avatar
pixhawk committed
116 117
    // Create the layout
    createLayout();
118

119
    // And make sure we're listening for future style changes
120
    connect(qgcApp()->toolbox()->settingsManager()->appSettings()->indoorPalette(), &Fact::rawValueChanged, this, &LinechartWidget::recolor);
121

LM's avatar
LM committed
122
    updateTimer->setInterval(updateInterval);
123
    connect(updateTimer, &QTimer::timeout, this, &LinechartWidget::refresh);
Gus Grubba's avatar
Gus Grubba committed
124 125
    connect(ui.uasSelectionBox, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &LinechartWidget::selectActiveSystem);

126
    readSettings();
Gus Grubba's avatar
Gus Grubba committed
127 128
    pUnit->setVisible(ui.showUnitsCheckBox->isChecked());
    connect(ui.showUnitsCheckBox, &QCheckBox::clicked, pUnit, &QLabel::setVisible);
pixhawk's avatar
pixhawk committed
129 130
}

131 132 133
LinechartWidget::~LinechartWidget()
{
    writeSettings();
pixhawk's avatar
pixhawk committed
134
    stopLogging();
135 136
    if (activePlot) delete activePlot;
    activePlot = NULL;
pixhawk's avatar
pixhawk committed
137 138
}

139 140 141 142 143 144 145 146 147 148 149
void LinechartWidget::selectActiveSystem(int mav)
{
    // -1: Unitialized, 0: all
    if (mav != selectedMAV && (selectedMAV != -1))
    {
        // Delete all curves
        // FIXME
    }
    selectedMAV = mav;
}

150 151 152
void LinechartWidget::selectAllCurves(bool all)
{
    QMap<QString, QLabel*>::iterator i;
153
    for (i = curveLabels->begin(); i != curveLabels->end(); ++i) {
154
        activePlot->setVisibleById(i.key(), all);
155 156 157
    }
}

158 159 160 161
void LinechartWidget::writeSettings()
{
    QSettings settings;
    settings.beginGroup("LINECHART");
162 163
    bool enforceGT = (!autoGroundTimeSet && timeButton->isChecked()) ? true : false;
    if (timeButton) settings.setValue("ENFORCE_GROUNDTIME", enforceGT);
164
    if (ui.showUnitsCheckBox) settings.setValue("SHOW_UNITS", ui.showUnitsCheckBox->isChecked());
165
    if (ui.shortNameCheckBox) settings.setValue("SHORT_NAMES", ui.shortNameCheckBox->isChecked());
166 167 168 169 170 171 172
    settings.endGroup();
}

void LinechartWidget::readSettings()
{
    QSettings settings;
    settings.beginGroup("LINECHART");
173
    if (activePlot) {
174 175
        timeButton->setChecked(settings.value("ENFORCE_GROUNDTIME", timeButton->isChecked()).toBool());
        activePlot->enforceGroundTime(settings.value("ENFORCE_GROUNDTIME", timeButton->isChecked()).toBool());
176
        timeButton->setChecked(settings.value("ENFORCE_GROUNDTIME", timeButton->isChecked()).toBool());
177
        //userGroundTimeSet = settings.value("USER_GROUNDTIME", timeButton->isChecked()).toBool();
178
    }
179
    if (ui.showUnitsCheckBox) ui.showUnitsCheckBox->setChecked(settings.value("SHOW_UNITS", ui.showUnitsCheckBox->isChecked()).toBool());
180
    if (ui.shortNameCheckBox) ui.shortNameCheckBox->setChecked(settings.value("SHORT_NAMES", ui.shortNameCheckBox->isChecked()).toBool());
181 182 183
    settings.endGroup();
}

pixhawk's avatar
pixhawk committed
184 185 186 187 188 189
void LinechartWidget::createLayout()
{
    // Create actions
    createActions();

    // Setup the plot group box area layout
190 191 192
    QVBoxLayout* vlayout = new QVBoxLayout(ui.diagramGroupBox);
    vlayout->setSpacing(4);
    vlayout->setMargin(2);
pixhawk's avatar
pixhawk committed
193 194

    // Create plot container widget
195 196 197
    activePlot = new LinechartPlot(this, sysid);
    // Activate automatic scrolling
    activePlot->setAutoScroll(true);
pixhawk's avatar
pixhawk committed
198 199 200 201 202

    // TODO Proper Initialization needed
    //    activePlot = getPlot(0);
    //    plotContainer->setPlot(activePlot);

203 204 205 206
    vlayout->addWidget(activePlot);

    QHBoxLayout *hlayout = new QHBoxLayout;
    vlayout->addLayout(hlayout);
pixhawk's avatar
pixhawk committed
207 208 209

    // Logarithmic scaling button
    scalingLogButton = createButton(this);
210
    scalingLogButton->setText(tr("LOG"));
pixhawk's avatar
pixhawk committed
211
    scalingLogButton->setCheckable(true);
212 213
    scalingLogButton->setToolTip(tr("Set logarithmic scale for Y axis"));
    scalingLogButton->setWhatsThis(tr("Set logarithmic scale for Y axis"));
214
    hlayout->addWidget(scalingLogButton);
pixhawk's avatar
pixhawk committed
215 216 217

    // Averaging spin box
    averageSpinBox = new QSpinBox(this);
218 219
    averageSpinBox->setToolTip(tr("Sliding window size to calculate mean and variance"));
    averageSpinBox->setWhatsThis(tr("Sliding window size to calculate mean and variance"));
pixhawk's avatar
pixhawk committed
220
    averageSpinBox->setMinimum(2);
221 222
    averageSpinBox->setValue(200);
    setAverageWindow(200);
223
    averageSpinBox->setMaximum(9999);
224
    hlayout->addWidget(averageSpinBox);
225
    connect(averageSpinBox,static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &LinechartWidget::setAverageWindow);
pixhawk's avatar
pixhawk committed
226 227 228

    // Log Button
    logButton = new QToolButton(this);
229 230
    logButton->setToolTip(tr("Start to log curve data into a CSV or TXT file"));
    logButton->setWhatsThis(tr("Start to log curve data into a CSV or TXT file"));
pixhawk's avatar
pixhawk committed
231
    logButton->setText(tr("Start Logging"));
232
    hlayout->addWidget(logButton);
233
    connect(logButton, &QToolButton::clicked, this, &LinechartWidget::startLogging);
pixhawk's avatar
pixhawk committed
234

235
    // Ground time button
236
    timeButton = new QCheckBox(this);
237
    timeButton->setText(tr("Ground Time"));
238 239
    timeButton->setToolTip(tr("Overwrite timestamp of data from vehicle with ground receive time. Helps if the plots are not visible because of missing or invalid onboard time."));
    timeButton->setWhatsThis(tr("Overwrite timestamp of data from vehicle with ground receive time. Helps if the plots are not visible because of missing or invalid onboard time."));
240
    hlayout->addWidget(timeButton);
241 242
    connect(timeButton.data(), &QCheckBox::clicked, activePlot, &LinechartPlot::enforceGroundTime);
    connect(timeButton.data(), &QCheckBox::clicked, this, &LinechartWidget::writeSettings);
243

244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
    hlayout->addStretch();

    QLabel *timeScaleLabel = new QLabel("Time axis:");
    hlayout->addWidget(timeScaleLabel);

    timeScaleCmb = new QComboBox(this);
    timeScaleCmb->addItem("10 seconds", 10);
    timeScaleCmb->addItem("20 seconds", 20);
    timeScaleCmb->addItem("30 seconds", 30);
    timeScaleCmb->addItem("40 seconds", 40);
    timeScaleCmb->addItem("50 seconds", 50);
    timeScaleCmb->addItem("1 minute", 60);
    timeScaleCmb->addItem("2 minutes", 60*2);
    timeScaleCmb->addItem("3 minutes", 60*3);
    timeScaleCmb->addItem("4 minutes", 60*4);
    timeScaleCmb->addItem("5 minutes", 60*5);
    timeScaleCmb->addItem("10 minutes", 60*10);
    //timeScaleCmb->setSizeAdjustPolicy(QComboBox::AdjustToContents);
    timeScaleCmb->setMinimumContentsLength(12);

    hlayout->addWidget(timeScaleCmb);
265 266
    connect(timeScaleCmb, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
            this, &LinechartWidget::timeScaleChanged);
267

268 269
    // Initialize the "Show units" checkbox. This is configured in the .ui file, so all
    // we do here is attach the clicked() signal.
270
    connect(ui.showUnitsCheckBox, &QCheckBox::clicked, this, &LinechartWidget::writeSettings);
pixhawk's avatar
pixhawk committed
271

272 273 274 275
    // Add actions
    averageSpinBox->setValue(activePlot->getAverageWindow());

    // Connect notifications from the user interface to the plot
276
    connect(this, &LinechartWidget::curveRemoved, activePlot, &LinechartPlot::hideCurve);
277 278

    // Update scrollbar when plot window changes (via translator method setPlotWindowPosition()
279
//    connect(activePlot, SIGNAL(windowPositionChanged(quint64)), this, SLOT(setPlotWindowPosition(quint64)));
280
    connect(activePlot, &LinechartPlot::curveRemoved, this, &LinechartWidget::removeCurve);
281 282

    // Update plot when scrollbar is moved (via translator method setPlotWindowPosition()
283 284 285
    //TODO: impossible to
    connect(this, static_cast<void (LinechartWidget::*)(quint64)>(&LinechartWidget::plotWindowPositionUpdated),
            activePlot, &LinechartPlot::setWindowPosition);
286 287

    // Set scaling
288
    connect(scalingLogButton, &QToolButton::toggled, this, &LinechartWidget::toggleLogarithmicScaling);
289 290
}

291 292 293 294 295
void LinechartWidget::timeScaleChanged(int index)
{
    activePlot->setPlotInterval(timeScaleCmb->itemData(index).toInt()*1000);
}

296 297 298 299 300 301
void LinechartWidget::toggleLogarithmicScaling(bool checked)
{
    if(checked)
        activePlot->setLogarithmicScaling();
    else
        activePlot->setLinearScaling();
pixhawk's avatar
pixhawk committed
302 303
}

304
void LinechartWidget::appendData(int uasId, const QString& curve, const QString& unit, const QVariant &variant, quint64 usec)
305
{
306 307 308 309 310 311
    QMetaType::Type type = static_cast<QMetaType::Type>(variant.type());
    bool ok;
    double value = variant.toDouble(&ok);
    if(!ok || type == QMetaType::QByteArray || type == QMetaType::QString)
        return;
    bool isDouble = type == QMetaType::Float || type == QMetaType::Double;
Gus Grubba's avatar
Gus Grubba committed
312
    QString curveID = curve + unit;
313

lm's avatar
lm committed
314 315
    if ((selectedMAV == -1 && isVisible()) || (selectedMAV == uasId && isVisible()))
    {
316
        // Order matters here, first append to plot, then update curve list
Gus Grubba's avatar
Gus Grubba committed
317
        activePlot->appendData(curveID, usec, value);
318
        // Store data
Gus Grubba's avatar
Gus Grubba committed
319
        QLabel* label = curveLabels->value(curveID, NULL);
320
        // Make sure the curve will be created if it does not yet exist
lm's avatar
lm committed
321 322
        if(!label)
        {
323
            if(!isDouble)
Gus Grubba's avatar
Gus Grubba committed
324
                intData.insert(curveID, 0);
325 326
            addCurve(curve, unit);
        }
327 328

        // Add int data
329
        if(!isDouble)
Gus Grubba's avatar
Gus Grubba committed
330
            intData.insert(curveID, variant.toInt());
331 332
    }

333 334 335 336
    if (lastTimestamp == 0 && usec != 0)
    {
        lastTimestamp = usec;
    } else if (usec != 0) {
337 338
        // Difference larger than 3 secs, enforce ground time
        if (((qint64)usec - (qint64)lastTimestamp) > 3000)
339 340
        {
            autoGroundTimeSet = true;
341 342 343 344 345
            // Tick ground time checkbox, but avoid state switching
            timeButton->blockSignals(true);
            timeButton->setChecked(true);
            timeButton->blockSignals(false);
            if (activePlot) activePlot->enforceGroundTime(true);
346
        }
347
        lastTimestamp = usec;
348 349
    }

350
    // Log data
lm's avatar
lm committed
351 352
    if (logging)
    {
Gus Grubba's avatar
Gus Grubba committed
353
        if (activePlot->isVisible(curveID))
lm's avatar
lm committed
354
        {
355
            if (usec == 0) usec = QGC::groundTimeMilliseconds();
356 357 358 359
            if (logStartTime == 0) logStartTime = usec;
            qint64 time = usec - logStartTime;
            if (time < 0) time = 0;

360 361
            QString line = QString("%1\t%2\t%3\t%4\n").arg(time).arg(uasId).arg(curve).arg(value, 0, 'e', 15);
            logFile->write(line.toLatin1());
362 363 364 365
        }
    }
}

366 367
void LinechartWidget::refresh()
{
LM's avatar
LM committed
368
    setUpdatesEnabled(false);
369
    QString str;
370
    // Value
371
    QMap<QString, QLabel*>::iterator i;
372 373
    for (i = curveLabels->begin(); i != curveLabels->end(); ++i) {
        if (intData.contains(i.key())) {
lm's avatar
lm committed
374
            str.sprintf("% 11i", intData.value(i.key()));
375
        } else {
lm's avatar
lm committed
376 377
            double val = activePlot->getCurrentValue(i.key());
            int intval = static_cast<int>(val);
378
            if (intval >= 100000 || intval <= -100000) {
lm's avatar
lm committed
379
                str.sprintf("% 11i", intval);
380
            } else if (intval >= 10000 || intval <= -10000) {
lm's avatar
lm committed
381
                str.sprintf("% 11.2f", val);
382
            } else if (intval >= 1000 || intval <= -1000) {
lm's avatar
lm committed
383
                str.sprintf("% 11.4f", val);
384
            } else {
lm's avatar
lm committed
385 386
                str.sprintf("% 11.6f", val);
            }
387
        }
388 389 390 391 392
        // Value
        i.value()->setText(str);
    }
    // Mean
    QMap<QString, QLabel*>::iterator j;
393
    for (j = curveMeans->begin(); j != curveMeans->end(); ++j) {
394
        double val = activePlot->getMean(j.key());
lm's avatar
lm committed
395
        int intval = static_cast<int>(val);
396
        if (intval >= 100000 || intval <= -100000) {
lm's avatar
lm committed
397
            str.sprintf("% 11i", intval);
398
        } else if (intval >= 10000 || intval <= -10000) {
399
            str.sprintf("% 11.2f", val);
400
        } else if (intval >= 1000 || intval <= -1000) {
lm's avatar
lm committed
401
            str.sprintf("% 11.4f", val);
402
        } else {
403 404
            str.sprintf("% 11.6f", val);
        }
405 406
        j.value()->setText(str);
    }
407 408 409 410 411 412 413
//    QMap<QString, QLabel*>::iterator k;
//    for (k = curveMedians->begin(); k != curveMedians->end(); ++k)
//    {
//        // Median
//        str.sprintf("%+.2f", activePlot->getMedian(k.key()));
//        k.value()->setText(str);
//    }
414
    QMap<QString, QLabel*>::iterator l;
415 416 417 418 419
    for (l = curveVariances->begin(); l != curveVariances->end(); ++l) {
        // Variance
        str.sprintf("% 8.3e", activePlot->getVariance(l.key()));
        l.value()->setText(str);
    }
LM's avatar
LM committed
420
    setUpdatesEnabled(true);
421 422
}

pixhawk's avatar
pixhawk committed
423 424
void LinechartWidget::startLogging()
{
lm's avatar
lm committed
425
    // Check if any curve is enabled
426
    if (!activePlot->anyCurveVisible()) {
dogmaphobic's avatar
dogmaphobic committed
427 428 429
        QGCMessageBox::critical(
            tr("No curves selected for logging."),
            tr("Please check all curves you want to log. Currently no data would be logged. Aborting the logging."));
lm's avatar
lm committed
430 431 432 433
        return;
    }

    // Let user select the log file name
434
    // QDate date(QDate::currentDate());
lm's avatar
lm committed
435
    // QString("./pixhawk-log-" + date.toString("yyyy-MM-dd") + "-" + QString::number(logindex) + ".log")
dogmaphobic's avatar
dogmaphobic committed
436 437 438
    QString fileName = QGCFileDialog::getSaveFileName(this,
        tr("Save Log File"),
        QStandardPaths::writableLocation(QStandardPaths::DesktopLocation),
439
        tr("Log Files (*.log)"),
440
        "log"); // Default type
441

442
    qDebug() << "SAVE FILE " << fileName;
443

dogmaphobic's avatar
dogmaphobic committed
444
    if (!fileName.isEmpty()) {
445
        logFile = new QFile(fileName);
Lorenz Meier's avatar
Lorenz Meier committed
446
        if (logFile->open(QIODevice::Truncate | QIODevice::WriteOnly | QIODevice::Text)) {
447
            logging = true;
448 449
            logStartTime = 0;
            curvesWidget->setEnabled(false);
450 451
            logindex++;
            logButton->setText(tr("Stop logging"));
452 453
            disconnect(logButton, &QToolButton::clicked, this, &LinechartWidget::startLogging);
            connect(logButton, &QToolButton::clicked, this, &LinechartWidget::stopLogging);
454
        }
pixhawk's avatar
pixhawk committed
455 456 457 458 459 460
    }
}

void LinechartWidget::stopLogging()
{
    logging = false;
461
    curvesWidget->setEnabled(true);
462
    if (logFile->isOpen()) {
pixhawk's avatar
pixhawk committed
463 464 465
        logFile->flush();
        logFile->close();
        // Postprocess log file
466
        compressor = new LogCompressor(logFile->fileName(), logFile->fileName());
467
        connect(compressor, &LogCompressor::finishedFile, this, &LinechartWidget::logfileWritten);
468

dogmaphobic's avatar
dogmaphobic committed
469 470 471 472 473
        QMessageBox::StandardButton button = QGCMessageBox::question(
            tr("Starting Log Compression"),
            tr("Should empty fields (e.g. due to packet drops) be filled with the previous value of the same variable (zero order hold)?"),
            QMessageBox::Yes | QMessageBox::No,
            QMessageBox::No);
474
        bool fill = (button == QMessageBox::Yes);
475 476

        compressor->startCompression(fill);
pixhawk's avatar
pixhawk committed
477 478
    }
    logButton->setText(tr("Start logging"));
479 480
    disconnect(logButton, &QToolButton::clicked, this, &LinechartWidget::stopLogging);
    connect(logButton, &QToolButton::clicked, this, &LinechartWidget::startLogging);
pixhawk's avatar
pixhawk committed
481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503
}

/**
 * The average window size defines the width of the sliding average
 * filter. It also defines the width of the sliding median filter.
 *
 * @param windowSize with (in values) of the sliding average/median filter. Minimum is 2
 */
void LinechartWidget::setAverageWindow(int windowSize)
{
    if (windowSize > 1) activePlot->setAverageWindow(windowSize);
}

void LinechartWidget::createActions()
{
}

/**
 * @brief Add a curve to the curve list
 *
 * @param curve The id-string of the curve
 * @see removeCurve()
 **/
504
void LinechartWidget::addCurve(const QString& curve, const QString& unit)
pixhawk's avatar
pixhawk committed
505
{
506
    LinechartPlot* plot = activePlot;
Gus Grubba's avatar
Gus Grubba committed
507 508
    QString curveID = curve + unit;
    curveNames.insert(curveID, curve);
509 510
    int labelRow = curvesWidgetLayout->rowCount();

511
    // Checkbox
Gus Grubba's avatar
Gus Grubba committed
512
    QCheckBox* checkBox = new QCheckBox(this);
pixhawk's avatar
pixhawk committed
513
    checkBox->setCheckable(true);
Gus Grubba's avatar
Gus Grubba committed
514
    checkBox->setObjectName(curveID);
515 516
    checkBox->setToolTip(tr("Enable the curve in the graph window"));
    checkBox->setWhatsThis(tr("Enable the curve in the graph window"));
Gus Grubba's avatar
Gus Grubba committed
517
    checkBoxes.insert(curveID, checkBox);
518
    curvesWidgetLayout->addWidget(checkBox, labelRow, 0);
pixhawk's avatar
pixhawk committed
519

520
    // Icon
521
    QWidget* colorIcon = new QWidget(this);
Gus Grubba's avatar
Gus Grubba committed
522
    colorIcons.insert(curveID, colorIcon);
pixhawk's avatar
pixhawk committed
523
    colorIcon->setMinimumSize(QSize(5, 14));
Gus Grubba's avatar
Gus Grubba committed
524
    colorIcon->setMaximumSize(QSize(5, 14));
525
    curvesWidgetLayout->addWidget(colorIcon, labelRow, 1);
pixhawk's avatar
pixhawk committed
526

527
    // Label
Gus Grubba's avatar
Gus Grubba committed
528 529 530
    QLabel* label = new QLabel(this);
    label->setText(getCurveName(curveID, ui.shortNameCheckBox->isChecked()));
    curveNameLabels.insert(curveID, label);
531
    curvesWidgetLayout->addWidget(label, labelRow, 2);
532

pixhawk's avatar
pixhawk committed
533
    // Value
Gus Grubba's avatar
Gus Grubba committed
534
    QLabel* value = new QLabel(this);
pixhawk's avatar
pixhawk committed
535
    value->setNum(0.00);
536
    value->setStyleSheet(QString("QLabel {font-family:\"Courier\"; font-weight: bold;}"));
537 538
    value->setToolTip(tr("Current value of %1 in %2 units").arg(curve, unit));
    value->setWhatsThis(tr("Current value of %1 in %2 units").arg(curve, unit));
Gus Grubba's avatar
Gus Grubba committed
539 540
    curveLabels->insert(curveID, value);
    curvesWidgetLayout->addWidget(value, labelRow, 3, Qt::AlignRight);
pixhawk's avatar
pixhawk committed
541

542
    // Unit
Gus Grubba's avatar
Gus Grubba committed
543
    QLabel* unitLabel = new QLabel(this);
544 545 546
    unitLabel->setText(unit);
    unitLabel->setToolTip(tr("Unit of ") + curve);
    unitLabel->setWhatsThis(tr("Unit of ") + curve);
Gus Grubba's avatar
Gus Grubba committed
547
    curveUnits.insert(curveID, unitLabel);
548
    curvesWidgetLayout->addWidget(unitLabel, labelRow, 4);
549
    unitLabel->setVisible(ui.showUnitsCheckBox->isChecked());
550
    connect(ui.showUnitsCheckBox, &QCheckBox::clicked, unitLabel, &QLabel::setVisible);
551

pixhawk's avatar
pixhawk committed
552
    // Mean
Gus Grubba's avatar
Gus Grubba committed
553
    QLabel* mean = new QLabel(this);
pixhawk's avatar
pixhawk committed
554
    mean->setNum(0.00);
lm's avatar
lm committed
555
    mean->setStyleSheet(QString("QLabel {font-family:\"Courier\"; font-weight: bold;}"));
556 557
    mean->setToolTip(tr("Arithmetic mean of %1 in %2 units").arg(curve, unit));
    mean->setWhatsThis(tr("Arithmetic mean of %1 in %2 units").arg(curve, unit));
Gus Grubba's avatar
Gus Grubba committed
558 559
    curveMeans->insert(curveID, mean);
    curvesWidgetLayout->addWidget(mean, labelRow, 5, Qt::AlignRight);
pixhawk's avatar
pixhawk committed
560

561 562 563 564 565
//    // Median
//    median = new QLabel(form);
//    value->setNum(0.00);
//    curveMedians->insert(curve, median);
//    horizontalLayout->addWidget(median);
pixhawk's avatar
pixhawk committed
566

567
    // Variance
Gus Grubba's avatar
Gus Grubba committed
568
    QLabel* variance = new QLabel(this);
569
    variance->setNum(0.00);
lm's avatar
lm committed
570
    variance->setStyleSheet(QString("QLabel {font-family:\"Courier\"; font-weight: bold;}"));
571 572
    variance->setToolTip(tr("Variance of %1 in (%2)^2 units").arg(curve, unit));
    variance->setWhatsThis(tr("Variance of %1 in (%2)^2 units").arg(curve, unit));
Gus Grubba's avatar
Gus Grubba committed
573 574
    curveVariances->insert(curveID, variance);
    curvesWidgetLayout->addWidget(variance, labelRow, 6, Qt::AlignRight);
575

pixhawk's avatar
pixhawk committed
576 577 578 579 580 581 582 583 584 585 586
    /* Color picker
    QColor color = QColorDialog::getColor(Qt::green, this);
         if (color.isValid()) {
             colorLabel->setText(color.name());
             colorLabel->setPalette(QPalette(color));
             colorLabel->setAutoFillBackground(true);
         }
        */

    // Set stretch factors so that the label gets the whole space

587 588 589
    // Load visibility settings
    // TODO

pixhawk's avatar
pixhawk committed
590
    // Connect actions
591 592 593
    connect(selectAllCheckBox, &QCheckBox::clicked, checkBox, &QCheckBox::setChecked);
    QObject::connect(checkBox, &QCheckBox::clicked, this, &LinechartWidget::takeButtonClick);
    QObject::connect(this, &LinechartWidget::curveVisible, plot, &LinechartPlot::setVisibleById);
pixhawk's avatar
pixhawk committed
594 595 596

    // Set UI components to initial state
    checkBox->setChecked(false);
Gus Grubba's avatar
Gus Grubba committed
597
    plot->setVisibleById(curveID, false);
pixhawk's avatar
pixhawk committed
598 599 600 601 602 603 604 605
}

/**
 * @brief Remove the curve from the curve list.
 *
 * @param curve The curve to remove
 * @see addCurve()
 **/
606
void LinechartWidget::removeCurve(QString curve)
pixhawk's avatar
pixhawk committed
607
{
608
    Q_UNUSED(curve)
609 610 611 612 613 614 615 616 617 618 619 620 621 622

    QWidget* widget = NULL;
    widget = curveLabels->take(curve);
    curvesWidgetLayout->removeWidget(widget);
    widget->deleteLater();
    widget = curveMeans->take(curve);
    curvesWidgetLayout->removeWidget(widget);
    widget->deleteLater();
    widget = curveMedians->take(curve);
    curvesWidgetLayout->removeWidget(widget);
    widget->deleteLater();
    widget = curveVariances->take(curve);
    curvesWidgetLayout->removeWidget(widget);
    widget->deleteLater();
623 624 625 626 627 628 629 630
    widget = colorIcons.take(curve);
    curvesWidgetLayout->removeWidget(widget);
    widget->deleteLater();
    widget = curveNameLabels.take(curve);
    curvesWidgetLayout->removeWidget(widget);
    widget->deleteLater();
    widget = curveUnits.take(curve);
    curvesWidgetLayout->removeWidget(widget);
631
    widget->deleteLater();
632 633 634 635
    QCheckBox* checkbox;
    checkbox = checkBoxes.take(curve);
    curvesWidgetLayout->removeWidget(checkbox);
    checkbox->deleteLater();
636 637 638 639 640
//    intData->remove(curve);
}

void LinechartWidget::recolor()
{
641
    activePlot->styleChanged(qgcApp()->toolbox()->settingsManager()->appSettings()->indoorPalette()->rawValue().toBool());
642
    foreach (const QString &key, colorIcons.keys())
643 644
    {
        QWidget* colorIcon = colorIcons.value(key, 0);
645
        if (colorIcon && !colorIcon->styleSheet().isEmpty())
646
        {
647 648 649
            QString colorstyle;
            QColor color = activePlot->getColorForCurve(key);
            colorstyle = colorstyle.sprintf("QWidget { background-color: #%02X%02X%02X; }", color.red(), color.green(), color.blue());
650 651 652 653 654
            colorIcon->setStyleSheet(colorstyle);
        }
    }
}

655 656 657 658 659
void LinechartWidget::setPlotFilterLineEditFocus()
{
    ui.plotFilterLineEdit->setFocus(Qt::ShortcutFocusReason);
}

660 661
void LinechartWidget::filterCurve(const QString &key, bool match)
{
662 663 664 665 666 667 668
        if (!checkBoxes[key]->isChecked())
        {
            colorIcons[key]->setVisible(match);
            curveNameLabels[key]->setVisible(match);
            (*curveLabels)[key]->setVisible(match);
            (*curveMeans)[key]->setVisible(match);
            (*curveVariances)[key]->setVisible(match);
Gus Grubba's avatar
Gus Grubba committed
669
            curveUnits[key]->setVisible(match && ui.showUnitsCheckBox->isChecked());
670 671
            checkBoxes[key]->setVisible(match);
        }
672 673 674 675 676 677 678 679 680 681
}

void LinechartWidget::filterCurves(const QString &filter)
{
    //qDebug() << "filterCurves: filter: " << filter;

    if (filter != "")
    {
        /* Hide Elements which do not match the filter pattern */
        QStringMatcher stringMatcher(filter, Qt::CaseInsensitive);
682
        foreach (const QString &key, colorIcons.keys())
683 684 685 686 687 688 689 690 691 692 693 694 695 696
        {
            if (stringMatcher.indexIn(key) < 0)
            {
                filterCurve(key, false);
            }
            else
            {
                filterCurve(key, true);
            }
        }
    }
    else
    {
        /* Show all Elements */
697
        foreach (const QString &key, colorIcons.keys())
698 699 700 701 702 703
        {
            filterCurve(key, true);
        }
    }
}

704
QString LinechartWidget::getCurveName(const QString& key, bool shortEnabled)
705
{
706
    if (shortEnabled)
707 708
    {
        QString name;
709 710
        QStringList parts = curveNames.value(key).split(".");
        if (parts.length() > 1)
711
        {
712 713 714 715 716 717
            name = parts.at(1);
        }
        else
        {
            name = parts.at(0);
        }
718

719
        const int sizeLimit = 20;
720

721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
        // Replace known words with abbreviations
        if (name.length() > sizeLimit)
        {
            name.replace("gyroscope", "gyro");
            name.replace("accelerometer", "acc");
            name.replace("magnetometer", "mag");
            name.replace("distance", "dist");
            name.replace("ailerons", "ail");
            name.replace("altitude", "alt");
            name.replace("waypoint", "wp");
            name.replace("throttle", "thr");
            name.replace("elevator", "elev");
            name.replace("rudder", "rud");
            name.replace("error", "err");
            name.replace("version", "ver");
            name.replace("message", "msg");
            name.replace("count", "cnt");
            name.replace("value", "val");
            name.replace("source", "src");
            name.replace("index", "idx");
            name.replace("type", "typ");
            name.replace("mode", "mod");
743
        }
744 745 746

        // Check if sub-part is still exceeding N chars
        if (name.length() > sizeLimit)
747
        {
748 749 750 751 752
            name.replace("a", "");
            name.replace("e", "");
            name.replace("i", "");
            name.replace("o", "");
            name.replace("u", "");
753
        }
754 755 756 757 758 759 760 761 762 763 764

        return name;
    }
    else
    {
        return curveNames.value(key);
    }
}

void LinechartWidget::setShortNames(bool enable)
{
765
    foreach (const QString &key, curveNames.keys())
766 767
    {
        curveNameLabels.value(key)->setText(getCurveName(key, enable));
768
    }
769
}
pixhawk's avatar
pixhawk committed
770

771 772 773
void LinechartWidget::showEvent(QShowEvent* event)
{
    Q_UNUSED(event);
774 775 776 777 778 779 780
    setActive(true);
}

void LinechartWidget::hideEvent(QHideEvent* event)
{
    Q_UNUSED(event);
    setActive(false);
781 782
}

783 784
void LinechartWidget::setActive(bool active)
{
785
    if (activePlot) {
786 787
        activePlot->setActive(active);
    }
788
    if (active) {
789
        updateTimer->start(updateInterval);
790
    } else {
791
        updateTimer->stop();
pixhawk's avatar
pixhawk committed
792 793 794 795 796 797 798 799 800 801 802
    }
}

/**
 * @brief Set the position of the plot window.
 * The plot covers only a portion of the complete time series. The scrollbar
 * allows to select a window of the time series. The right edge of the window is
 * defined proportional to the position of the scrollbar.
 *
 * @param scrollBarValue The value of the scrollbar, in the range from MIN_TIME_SCROLLBAR_VALUE to MAX_TIME_SCROLLBAR_VALUE
 **/
803 804
void LinechartWidget::setPlotWindowPosition(int scrollBarValue)
{
pixhawk's avatar
pixhawk committed
805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849
    plotWindowLock.lockForWrite();
    // Disable automatic scrolling immediately
    int scrollBarRange = (MAX_TIME_SCROLLBAR_VALUE - MIN_TIME_SCROLLBAR_VALUE);
    double position = (static_cast<double>(scrollBarValue) - MIN_TIME_SCROLLBAR_VALUE) / scrollBarRange;
    quint64 scrollInterval;

    // Activate automatic scrolling if scrollbar is at the right edge
    if(scrollBarValue > MAX_TIME_SCROLLBAR_VALUE - (MAX_TIME_SCROLLBAR_VALUE - MIN_TIME_SCROLLBAR_VALUE) * 0.01f) {
        activePlot->setAutoScroll(true);
    } else {
        activePlot->setAutoScroll(false);
        quint64 rightPosition;
        /* If the data exceeds the plot window, choose the position according to the scrollbar position */
        if(activePlot->getDataInterval() > activePlot->getPlotInterval()) {
            scrollInterval = activePlot->getDataInterval() - activePlot->getPlotInterval();
            rightPosition = activePlot->getMinTime() + activePlot->getPlotInterval() + (scrollInterval * position);
        } else {
            /* If the data interval is smaller as the plot interval, clamp the scrollbar to the right */
            rightPosition = activePlot->getMinTime() + activePlot->getPlotInterval();
        }
        emit plotWindowPositionUpdated(rightPosition);
    }


    // The slider position must be mapped onto an interval of datainterval - plotinterval,
    // because the slider position defines the right edge of the plot window. The leftmost
    // slider position must therefore map to the start of the data interval + plot interval
    // to ensure that the plot is not empty

    //  start> |-- plot interval --||-- (data interval - plotinterval) --| <end

    //@TODO Add notification of scrollbar here
    //plot->setWindowPosition(rightPosition);

    plotWindowLock.unlock();
}

/**
 * @brief Receive an updated plot window position.
 * The plot window can be changed by the arrival of new data or by
 * other user interaction. The scrollbar and other UI components
 * can be notified by calling this method.
 *
 * @param position The absolute position of the right edge of the plot window, in milliseconds
 **/
850 851
void LinechartWidget::setPlotWindowPosition(quint64 position)
{
pixhawk's avatar
pixhawk committed
852 853 854 855 856 857 858
    plotWindowLock.lockForWrite();
    // Calculate the relative position
    double pos;

    // A relative position makes only sense if the plot is filled
    if(activePlot->getDataInterval() > activePlot->getPlotInterval()) {
        //TODO @todo Implement the scrollbar enabling in a more elegant way
859
        //scrollbar->setDisabled(false);
pixhawk's avatar
pixhawk committed
860 861 862 863 864 865
        quint64 scrollInterval = position - activePlot->getMinTime() - activePlot->getPlotInterval();



        pos = (static_cast<double>(scrollInterval) / (activePlot->getDataInterval() - activePlot->getPlotInterval()));
    } else {
866
        //scrollbar->setDisabled(true);
pixhawk's avatar
pixhawk committed
867 868 869 870 871 872 873 874 875 876 877 878 879 880 881
        pos = 1;
    }
    plotWindowLock.unlock();

    emit plotWindowPositionUpdated(static_cast<int>(pos * (MAX_TIME_SCROLLBAR_VALUE - MIN_TIME_SCROLLBAR_VALUE)));
}

/**
 * @brief Set the time interval the plot displays.
 * The time interval of the plot can be adjusted by this method. If the
 * data covers less time than the interval, the plot will be filled from
 * the right to left
 *
 * @param interval The time interval to plot
 **/
882 883
void LinechartWidget::setPlotInterval(quint64 interval)
{
pixhawk's avatar
pixhawk committed
884 885 886 887 888
    activePlot->setPlotInterval(interval);
}

/**
 * @brief Take the click of a curve activation / deactivation button.
889 890 891
 * This method allows to map a button to a plot curve. The text of the
 * button must equal the curve name to activate / deactivate. If the checkbox
 * was clicked, show the curve color, otherwise clear the coloring.
pixhawk's avatar
pixhawk committed
892 893 894
 *
 * @param checked The visibility of the curve: true to display the curve, false otherwise
 **/
895 896
void LinechartWidget::takeButtonClick(bool checked)
{
pixhawk's avatar
pixhawk committed
897 898 899

    QCheckBox* button = qobject_cast<QCheckBox*>(QObject::sender());

900 901
    if(button != NULL)
    {
902
        activePlot->setVisibleById(button->objectName(), checked);
903 904
        QWidget* colorIcon = colorIcons.value(button->objectName(), 0);
        if (colorIcon)
905
        {
906 907 908 909 910 911 912 913 914 915 916
            if (checked)
            {
                QColor color = activePlot->getColorForCurve(button->objectName());
                if (color.isValid())
                {
                    QString colorstyle;
                    colorstyle = colorstyle.sprintf("QWidget { background-color: #%02X%02X%02X; }", color.red(), color.green(), color.blue());
                    colorIcon->setStyleSheet(colorstyle);
                }
            }
            else
917
            {
918
                colorIcon->setStyleSheet("");
919 920
            }
        }
pixhawk's avatar
pixhawk committed
921 922 923 924 925 926 927 928 929 930
    }
}

/**
 * @brief Factory method to create a new button.
 *
 * @param imagename The name of the image (should be placed at the standard icon location)
 * @param text The button text
 * @param parent The parent object (to ensure that the memory is freed after the deletion of the button)
 **/
931 932
QToolButton* LinechartWidget::createButton(QWidget* parent)
{
pixhawk's avatar
pixhawk committed
933 934 935 936 937 938
    QToolButton* button = new QToolButton(parent);
    button->setMinimumSize(QSize(20, 20));
    button->setMaximumSize(60, 20);
    button->setGeometry(button->x(), button->y(), 20, 20);
    return button;
}