sadmen
/
openpilot_comma
mirror of https://github.com/commaai/openpilot.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

cabana: add a slider to adjust chart range from 1 sec to max cached seconds. (#27005)

Browse Source 
* add slider to set chart range

* set minumu to 1 sec

* make chart work in any range

* cleanup

* rename to max_cached_minitues

* more

* dont draw out of plotarea

* cleanup

* updateLayout after chart removed

* cleanup

* fix clamp

* usea same cur_sec to update all charts
old-commit-hash: f0d22f88e1
beeps
Dean Lee 3 years ago committed by GitHub
parent 0ffdb9bda5
commit e675648a16
6 changed files with 110 additions and 136 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 171
      tools/cabana/chartswidget.cc
  2. 17
      tools/cabana/chartswidget.h
  3. 29
      tools/cabana/settings.cc
  4. 7
      tools/cabana/settings.h
  5. 2
      tools/cabana/streams/livestream.h
  6. 4
      tools/cabana/streams/replaystream.cc

171
tools/cabana/chartswidget.cc
Unescape View File

@ -2,10 +2,11 @@
#include <QApplication> #include <QApplication>
#include <QCompleter> #include <QCompleter>
#include <QDialogButtonBox>
#include <QDrag> #include <QDrag>
#include <QLineEdit>
#include <QFutureSynchronizer> #include <QFutureSynchronizer>
#include <QGraphicsLayout> #include <QGraphicsLayout>
#include <QLineEdit>
#include <QRubberBand> #include <QRubberBand>
#include <QToolBar> #include <QToolBar>
#include <QToolButton> #include <QToolButton>
@ -27,7 +28,6 @@ ChartsWidget::ChartsWidget(QWidget *parent) : QWidget(parent) {
title_label->setContentsMargins(0, 0, 12, 0); title_label->setContentsMargins(0, 0, 12, 0);
columns_cb = new QComboBox(this); columns_cb = new QComboBox(this);
columns_cb->addItems({"1", "2", "3", "4"}); columns_cb->addItems({"1", "2", "3", "4"});
columns_cb->setCurrentIndex(std::clamp(settings.chart_column_count - 1, 0, 3));
toolbar->addWidget(new QLabel(tr("Columns:"))); toolbar->addWidget(new QLabel(tr("Columns:")));
toolbar->addWidget(columns_cb); toolbar->addWidget(columns_cb);
@ -35,8 +35,16 @@ ChartsWidget::ChartsWidget(QWidget *parent) : QWidget(parent) {
stretch_label->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred); stretch_label->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
toolbar->addWidget(stretch_label); toolbar->addWidget(stretch_label);
show_all_values_btn = toolbar->addAction(""); toolbar->addWidget(new QLabel(tr("Range:")));
toolbar->addWidget(range_label = new QLabel()); toolbar->addWidget(range_lb = new QLabel(this));
range_slider = new QSlider(Qt::Horizontal, this);
range_slider->setToolTip(tr("Set the chart range"));
range_slider->setRange(1, settings.max_cached_minutes * 60);
range_slider->setSingleStep(1);
range_slider->setPageStep(60); // 1 min
toolbar->addWidget(range_slider);
toolbar->addWidget(zoom_range_lb = new QLabel());
reset_zoom_btn = toolbar->addAction(bootstrapPixmap("arrow-counterclockwise"), ""); reset_zoom_btn = toolbar->addAction(bootstrapPixmap("arrow-counterclockwise"), "");
reset_zoom_btn->setToolTip(tr("Reset zoom (drag on chart to zoom X-Axis)")); reset_zoom_btn->setToolTip(tr("Reset zoom (drag on chart to zoom X-Axis)"));
remove_all_btn = toolbar->addAction(bootstrapPixmap("x"), ""); remove_all_btn = toolbar->addAction(bootstrapPixmap("x"), "");
@ -48,8 +56,7 @@ ChartsWidget::ChartsWidget(QWidget *parent) : QWidget(parent) {
QWidget *charts_container = new QWidget(this); QWidget *charts_container = new QWidget(this);
QVBoxLayout *charts_main_layout = new QVBoxLayout(charts_container); QVBoxLayout *charts_main_layout = new QVBoxLayout(charts_container);
charts_main_layout->setContentsMargins(0, 0, 0, 0); charts_main_layout->setContentsMargins(0, 0, 0, 0);
charts_layout = new QGridLayout(charts_container); charts_main_layout->addLayout(charts_layout = new QGridLayout);
charts_main_layout->addLayout(charts_layout);
charts_main_layout->addStretch(0); charts_main_layout->addStretch(0);
QScrollArea *charts_scroll = new QScrollArea(this); QScrollArea *charts_scroll = new QScrollArea(this);
@ -58,20 +65,24 @@ ChartsWidget::ChartsWidget(QWidget *parent) : QWidget(parent) {
charts_scroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); charts_scroll->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
main_layout->addWidget(charts_scroll); main_layout->addWidget(charts_scroll);
max_chart_range = settings.max_chart_x_range;
use_dark_theme = QApplication::style()->standardPalette().color(QPalette::WindowText).value() >
QApplication::style()->standardPalette().color(QPalette::Background).value();
updateToolBar();
align_charts_timer = new QTimer(this); align_charts_timer = new QTimer(this);
align_charts_timer->setSingleShot(true); align_charts_timer->setSingleShot(true);
align_charts_timer->callOnTimeout(this, &ChartsWidget::alignCharts); align_charts_timer->callOnTimeout(this, &ChartsWidget::alignCharts);
column_count = settings.chart_column_count;
// init settings
use_dark_theme = QApplication::style()->standardPalette().color(QPalette::WindowText).value() >
QApplication::style()->standardPalette().color(QPalette::Background).value();
column_count = std::clamp(settings.chart_column_count, 1, columns_cb->count());
max_chart_range = std::clamp(settings.chart_range, 1, settings.max_cached_minutes * 60);
display_range = {0, max_chart_range};
columns_cb->setCurrentIndex(column_count);
range_slider->setValue(max_chart_range);
updateToolBar();
QObject::connect(dbc(), &DBCManager::DBCFileChanged, this, &ChartsWidget::removeAll); QObject::connect(dbc(), &DBCManager::DBCFileChanged, this, &ChartsWidget::removeAll);
QObject::connect(can, &AbstractStream::eventsMerged, this, &ChartsWidget::updateState); QObject::connect(can, &AbstractStream::eventsMerged, this, &ChartsWidget::eventsMerged);
QObject::connect(can, &AbstractStream::updated, this, &ChartsWidget::updateState); QObject::connect(can, &AbstractStream::updated, this, &ChartsWidget::updateState);
QObject::connect(show_all_values_btn, &QAction::triggered, this, &ChartsWidget::showAllData); QObject::connect(range_slider, &QSlider::valueChanged, this, &ChartsWidget::setMaxChartRange);
QObject::connect(remove_all_btn, &QAction::triggered, this, &ChartsWidget::removeAll); QObject::connect(remove_all_btn, &QAction::triggered, this, &ChartsWidget::removeAll);
QObject::connect(reset_zoom_btn, &QAction::triggered, this, &ChartsWidget::zoomReset); QObject::connect(reset_zoom_btn, &QAction::triggered, this, &ChartsWidget::zoomReset);
QObject::connect(columns_cb, SIGNAL(activated(int)), SLOT(setColumnCount(int))); QObject::connect(columns_cb, SIGNAL(activated(int)), SLOT(setColumnCount(int)));
@ -83,34 +94,16 @@ ChartsWidget::ChartsWidget(QWidget *parent) : QWidget(parent) {
}); });
} }
void ChartsWidget::updateDisplayRange() { void ChartsWidget::eventsMerged() {
auto events = can->events(); {
double min_event_sec = (events->front()->mono_time / (double)1e9) - can->routeStartTime(); assert(!can->liveStreaming());
double max_event_sec = (events->back()->mono_time / (double)1e9) - can->routeStartTime();
const double cur_sec = can->currentSec();
if (!can->liveStreaming()) {
auto prev_range = display_range;
if (cur_sec < display_range.first || cur_sec >= (display_range.second - 5)) {
// reached the end, or seeked to a timestamp out of range.
display_range.first = cur_sec - 5;
}
display_range.first = std::floor(std::max(min_event_sec, display_range.first));
display_range.second = std::floor(std::min(display_range.first + max_chart_range, max_event_sec));
if (prev_range != display_range) {
QFutureSynchronizer<void> future_synchronizer; QFutureSynchronizer<void> future_synchronizer;
const auto events = can->events();
for (auto c : charts) { for (auto c : charts) {
future_synchronizer.addFuture(QtConcurrent::run(c, &ChartView::setEventsRange, display_range)); future_synchronizer.addFuture(QtConcurrent::run(c, &ChartView::updateSeries, nullptr, events, true));
}
}
} else {
if (cur_sec >= (display_range.second - 5)) {
display_range.first = std::floor(std::max(min_event_sec, cur_sec - settings.max_chart_x_range / 2.0));
}
display_range.second = std::floor(display_range.first + settings.max_chart_x_range);
for (auto c : charts) {
c->updateSeries(nullptr, events, false);
} }
} }
updateState();
} }
void ChartsWidget::zoomIn(double min, double max) { void ChartsWidget::zoomIn(double min, double max) {
@ -128,49 +121,61 @@ void ChartsWidget::zoomReset() {
void ChartsWidget::updateState() { void ChartsWidget::updateState() {
if (charts.isEmpty()) return; if (charts.isEmpty()) return;
if (can->liveStreaming()) {
// appends incoming events to the end of series
const auto events = can->events();
for (auto c : charts) {
c->updateSeries(nullptr, events, false);
}
}
const double cur_sec = can->currentSec();
if (!is_zoomed) { if (!is_zoomed) {
updateDisplayRange(); double pos = (cur_sec - display_range.first) / max_chart_range;
} else if (can->currentSec() < zoomed_range.first || can->currentSec() >= zoomed_range.second) { if (pos > 0.8) {
const double min_event_sec = (can->events()->front()->mono_time / (double)1e9) - can->routeStartTime();
display_range.first = std::floor(std::max(min_event_sec, cur_sec - max_chart_range * 0.2));
}
display_range.second = std::floor(display_range.first + max_chart_range);
} else if (cur_sec < zoomed_range.first || cur_sec >= zoomed_range.second) {
// loop in zoommed range
can->seekTo(zoomed_range.first); can->seekTo(zoomed_range.first);
} }
const auto &range = is_zoomed ? zoomed_range : display_range;
setUpdatesEnabled(false); setUpdatesEnabled(false);
const auto &range = is_zoomed ? zoomed_range : display_range;
for (auto c : charts) { for (auto c : charts) {
c->setDisplayRange(range.first, range.second); c->updatePlot(cur_sec, range.first, range.second);
c->scene()->invalidate({}, QGraphicsScene::ForegroundLayer);
} }
setUpdatesEnabled(true); setUpdatesEnabled(true);
} }
void ChartsWidget::showAllData() { void ChartsWidget::setMaxChartRange(int value) {
bool switch_to_show_all = max_chart_range == settings.max_chart_x_range; max_chart_range = settings.chart_range = value;
max_chart_range = switch_to_show_all ? settings.cached_segment_limit * 60 double current_sec = can->currentSec();
: settings.max_chart_x_range; const double min_event_sec = (can->events()->front()->mono_time / (double)1e9) - can->routeStartTime();
max_chart_range = std::min(max_chart_range, (uint32_t)can->totalSeconds()); // keep current_sec's pos
double pos = (current_sec - display_range.first) / (display_range.second - display_range.first);
display_range.first = std::floor(std::max(min_event_sec, current_sec - max_chart_range * (1.0 - pos)));
display_range.second = std::floor(display_range.first + max_chart_range);
updateToolBar(); updateToolBar();
updateState(); updateState();
} }
void ChartsWidget::updateToolBar() { void ChartsWidget::updateToolBar() {
int min_range = std::min(settings.max_chart_x_range, (int)can->totalSeconds()); range_lb->setText(QString(" %1:%2 ").arg(max_chart_range / 60, 2, 10, QLatin1Char('0')).arg(max_chart_range % 60, 2, 10, QLatin1Char('0')));
bool displaying_all = max_chart_range != min_range; zoom_range_lb->setText(is_zoomed ? tr("Zooming: %1 - %2").arg(zoomed_range.first, 0, 'f', 2).arg(zoomed_range.second, 0, 'f', 2) : "");
show_all_values_btn->setText(tr("%1 minutes").arg(max_chart_range / 60)); title_label->setText(tr("Charts: %1").arg(charts.size()));
show_all_values_btn->setToolTip(tr("Click to display %1 data").arg(displaying_all ? tr("%1 minutes").arg(min_range / 60) : tr("ALL cached")));
show_all_values_btn->setVisible(!is_zoomed && !can->liveStreaming());
remove_all_btn->setEnabled(!charts.isEmpty());
reset_zoom_btn->setEnabled(is_zoomed);
range_label->setText(is_zoomed ? tr("%1 - %2").arg(zoomed_range.first, 0, 'f', 2).arg(zoomed_range.second, 0, 'f', 2) : "");
title_label->setText(charts.size() > 0 ? tr("Charts (%1)").arg(charts.size()) : tr("Charts"));
dock_btn->setIcon(bootstrapPixmap(docking ? "arrow-up-right" : "arrow-down-left")); dock_btn->setIcon(bootstrapPixmap(docking ? "arrow-up-right" : "arrow-down-left"));
dock_btn->setToolTip(docking ? tr("Undock charts") : tr("Dock charts")); dock_btn->setToolTip(docking ? tr("Undock charts") : tr("Dock charts"));
remove_all_btn->setEnabled(!charts.isEmpty());
reset_zoom_btn->setEnabled(is_zoomed);
} }
void ChartsWidget::settingChanged() { void ChartsWidget::settingChanged() {
range_slider->setRange(1, settings.max_cached_minutes * 60);
for (auto c : charts) { for (auto c : charts) {
c->setFixedHeight(settings.chart_height); c->setFixedHeight(settings.chart_height);
columns_cb->setCurrentIndex(std::clamp(settings.chart_column_count - 1, 0, columns_cb->count() - 1));
setColumnCount(settings.chart_column_count);
} }
} }
@ -189,11 +194,8 @@ void ChartsWidget::showChart(const QString &id, const Signal *sig, bool show, bo
chart = new ChartView(this); chart = new ChartView(this);
chart->setFixedHeight(settings.chart_height); chart->setFixedHeight(settings.chart_height);
chart->setMinimumWidth(CHART_MIN_WIDTH); chart->setMinimumWidth(CHART_MIN_WIDTH);
chart->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed); chart->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
chart->chart()->setTheme(use_dark_theme ? QChart::QChart::ChartThemeDark : QChart::ChartThemeLight); chart->chart()->setTheme(use_dark_theme ? QChart::QChart::ChartThemeDark : QChart::ChartThemeLight);
chart->setEventsRange(display_range);
auto range = is_zoomed ? zoomed_range : display_range;
chart->setDisplayRange(range.first, range.second);
QObject::connect(chart, &ChartView::remove, [=]() { removeChart(chart); }); QObject::connect(chart, &ChartView::remove, [=]() { removeChart(chart); });
QObject::connect(chart, &ChartView::zoomIn, this, &ChartsWidget::zoomIn); QObject::connect(chart, &ChartView::zoomIn, this, &ChartsWidget::zoomIn);
QObject::connect(chart, &ChartView::zoomReset, this, &ChartsWidget::zoomReset); QObject::connect(chart, &ChartView::zoomReset, this, &ChartsWidget::zoomReset);
@ -204,6 +206,7 @@ void ChartsWidget::showChart(const QString &id, const Signal *sig, bool show, bo
updateLayout(); updateLayout();
} }
chart->addSeries(id, sig); chart->addSeries(id, sig);
updateState();
} else if (!show && chart) { } else if (!show && chart) {
chart->removeSeries(id, sig); chart->removeSeries(id, sig);
} }
@ -214,7 +217,7 @@ void ChartsWidget::showChart(const QString &id, const Signal *sig, bool show, bo
void ChartsWidget::setColumnCount(int n) { void ChartsWidget::setColumnCount(int n) {
n = std::clamp(n + 1, 1, columns_cb->count()); n = std::clamp(n + 1, 1, columns_cb->count());
if (column_count != n) { if (column_count != n) {
column_count = n; column_count = settings.chart_column_count = n;
updateLayout(); updateLayout();
} }
} }
@ -239,6 +242,7 @@ void ChartsWidget::removeChart(ChartView *chart) {
chart->deleteLater(); chart->deleteLater();
updateToolBar(); updateToolBar();
alignCharts(); alignCharts();
updateLayout();
emit seriesChanged(); emit seriesChanged();
} }
@ -440,36 +444,28 @@ void ChartView::updateTitle() {
} }
} }
void ChartView::setEventsRange(const std::pair<double, double> &range) { void ChartView::updatePlot(double cur, double min, double max) {
if (range != events_range) { cur_sec = cur;
events_range = range;
updateSeries();
}
}
void ChartView::setDisplayRange(double min, double max) {
if (min != axis_x->min() || max != axis_x->max()) { if (min != axis_x->min() || max != axis_x->max()) {
axis_x->setRange(min, max); axis_x->setRange(min, max);
updateAxisY(); updateAxisY();
} }
scene()->invalidate({}, QGraphicsScene::ForegroundLayer);
} }
void ChartView::updateSeries(const Signal *sig, const std::vector<Event *> *events, bool clear) { void ChartView::updateSeries(const Signal *sig, const std::vector<Event *> *events, bool clear) {
if (!events) events = can->events(); events = events ? events : can->events();
if (!events || sigs.isEmpty()) return;
for (auto &s : sigs) { for (auto &s : sigs) {
if (!sig || s.sig == sig) { if (!sig || s.sig == sig) {
if (clear) { if (clear) {
s.vals.clear(); s.vals.clear();
s.vals.reserve(settings.max_cached_minutes * 60 * 100); // [n]seconds * 100hz
s.last_value_mono_time = 0; s.last_value_mono_time = 0;
} }
double route_start_time = can->routeStartTime(); double route_start_time = can->routeStartTime();
uint64_t begin_ts = can->liveStreaming() ? s.last_value_mono_time : (route_start_time + events_range.first) * 1e9; Event begin_event(cereal::Event::Which::INIT_DATA, s.last_value_mono_time);
Event begin_event(cereal::Event::Which::INIT_DATA, begin_ts);
auto begin = std::upper_bound(events->begin(), events->end(), &begin_event, Event::lessThan()); auto begin = std::upper_bound(events->begin(), events->end(), &begin_event, Event::lessThan());
uint64_t end_ns = can->liveStreaming() ? events->back()->mono_time : (route_start_time + events_range.second) * 1e9; for (auto it = begin; it != events->end(); ++it) {
for (auto it = begin; it != events->end() && (*it)->mono_time <= end_ns; ++it) {
if ((*it)->which == cereal::Event::Which::CAN) { if ((*it)->which == cereal::Event::Which::CAN) {
for (const auto &c : (*it)->event.getCan()) { for (const auto &c : (*it)->event.getCan()) {
if (s.source == c.getSrc() && s.address == c.getAddress()) { if (s.source == c.getSrc() && s.address == c.getAddress()) {
@ -481,13 +477,8 @@ void ChartView::updateSeries(const Signal *sig, const std::vector<Event*> *event
} }
} }
} }
if (!s.vals.isEmpty()) { if (events->size()) {
auto [min_v, max_v] = std::minmax_element(s.vals.begin(), s.vals.end(), [](auto &l, auto &r) { return l.y() < r.y(); });
s.min_y = min_v->y();
s.max_y = max_v->y();
s.last_value_mono_time = events->back()->mono_time; s.last_value_mono_time = events->back()->mono_time;
} else {
s.min_y = s.max_y = 0;
} }
s.series->replace(s.vals); s.series->replace(s.vals);
updateAxisY(); updateAxisY();
@ -501,12 +492,6 @@ void ChartView::updateAxisY() {
double min_y = std::numeric_limits<double>::max(); double min_y = std::numeric_limits<double>::max();
double max_y = std::numeric_limits<double>::lowest(); double max_y = std::numeric_limits<double>::lowest();
if (can->liveStreaming() || events_range == std::pair{axis_x->min(), axis_x->max()}) {
for (auto &s : sigs) {
if (s.min_y < min_y) min_y = s.min_y;
if (s.max_y > max_y) max_y = s.max_y;
}
} else {
for (auto &s : sigs) { for (auto &s : sigs) {
auto begin = std::lower_bound(s.vals.begin(), s.vals.end(), axis_x->min(), [](auto &p, double x) { return p.x() < x; }); auto begin = std::lower_bound(s.vals.begin(), s.vals.end(), axis_x->min(), [](auto &p, double x) { return p.x() < x; });
for (auto it = begin; it != s.vals.end() && it->x() <= axis_x->max(); ++it) { for (auto it = begin; it != s.vals.end() && it->x() <= axis_x->max(); ++it) {
@ -514,7 +499,6 @@ void ChartView::updateAxisY() {
if (it->y() > max_y) max_y = it->y(); if (it->y() > max_y) max_y = it->y();
} }
} }
}
if (min_y == std::numeric_limits<double>::max()) min_y = 0; if (min_y == std::numeric_limits<double>::max()) min_y = 0;
if (max_y == std::numeric_limits<double>::lowest()) max_y = 0; if (max_y == std::numeric_limits<double>::lowest()) max_y = 0;
@ -664,7 +648,8 @@ void ChartView::dropEvent(QDropEvent *event) {
} }
void ChartView::drawForeground(QPainter *painter, const QRectF &rect) { void ChartView::drawForeground(QPainter *painter, const QRectF &rect) {
qreal x = chart()->mapToPosition(QPointF{can->currentSec(), 0}).x(); qreal x = chart()->mapToPosition(QPointF{cur_sec, 0}).x();
x = std::clamp(x, chart()->plotArea().left(), chart()->plotArea().right());
qreal y1 = chart()->plotArea().top() - 2; qreal y1 = chart()->plotArea().top() - 2;
qreal y2 = chart()->plotArea().bottom() + 2; qreal y2 = chart()->plotArea().bottom() + 2;
painter->setPen(QPen(chart()->titleBrush().color(), 2)); painter->setPen(QPen(chart()->titleBrush().color(), 2));

17
tools/cabana/chartswidget.h
Unescape View File

@ -1,12 +1,12 @@
#pragma once #pragma once
#include <QComboBox> #include <QComboBox>
#include <QDialogButtonBox>
#include <QDragEnterEvent> #include <QDragEnterEvent>
#include <QGridLayout> #include <QGridLayout>
#include <QLabel> #include <QLabel>
#include <QListWidget> #include <QListWidget>
#include <QGraphicsProxyWidget> #include <QGraphicsProxyWidget>
#include <QSlider>
#include <QTimer> #include <QTimer>
#include <QtCharts/QChartView> #include <QtCharts/QChartView>
#include <QtCharts/QLineSeries> #include <QtCharts/QLineSeries>
@ -26,8 +26,7 @@ public:
void removeSeries(const QString &msg_id, const Signal *sig); void removeSeries(const QString &msg_id, const Signal *sig);
bool hasSeries(const QString &msg_id, const Signal *sig) const; bool hasSeries(const QString &msg_id, const Signal *sig) const;
void updateSeries(const Signal *sig = nullptr, const std::vector<Event*> *events = nullptr, bool clear = true); void updateSeries(const Signal *sig = nullptr, const std::vector<Event*> *events = nullptr, bool clear = true);
void setEventsRange(const std::pair<double, double> &range); void updatePlot(double cur, double min, double max);
void setDisplayRange(double min, double max);
void setPlotAreaLeftPosition(int pos); void setPlotAreaLeftPosition(int pos);
qreal getYAsixLabelWidth() const; qreal getYAsixLabelWidth() const;
@ -37,8 +36,6 @@ public:
uint32_t address = 0; uint32_t address = 0;
const Signal *sig = nullptr; const Signal *sig = nullptr;
QLineSeries *series = nullptr; QLineSeries *series = nullptr;
double min_y = 0;
double max_y = 0;
QVector<QPointF> vals; QVector<QPointF> vals;
uint64_t last_value_mono_time = 0; uint64_t last_value_mono_time = 0;
}; };
@ -79,8 +76,8 @@ private:
QPointF track_pt; QPointF track_pt;
QGraphicsProxyWidget *close_btn_proxy; QGraphicsProxyWidget *close_btn_proxy;
QGraphicsProxyWidget *manage_btn_proxy; QGraphicsProxyWidget *manage_btn_proxy;
std::pair<double, double> events_range = {0, 0};
QList<SigItem> sigs; QList<SigItem> sigs;
double cur_sec = 0;
const QString mime_type = "application/x-cabanachartview"; const QString mime_type = "application/x-cabanachartview";
}; };
@ -106,21 +103,21 @@ private:
void removeChart(ChartView *chart); void removeChart(ChartView *chart);
void eventsMerged(); void eventsMerged();
void updateState(); void updateState();
void updateDisplayRange();
void zoomIn(double min, double max); void zoomIn(double min, double max);
void zoomReset(); void zoomReset();
void updateToolBar(); void updateToolBar();
void removeAll(); void removeAll();
void showAllData(); void setMaxChartRange(int value);
void updateLayout(); void updateLayout();
void settingChanged(); void settingChanged();
bool eventFilter(QObject *obj, QEvent *event) override; bool eventFilter(QObject *obj, QEvent *event) override;
ChartView *findChart(const QString &id, const Signal *sig); ChartView *findChart(const QString &id, const Signal *sig);
QLabel *title_label; QLabel *title_label;
QLabel *range_label; QLabel *zoom_range_lb;
QLabel *range_lb;
QSlider *range_slider;
bool docking = true; bool docking = true;
QAction *show_all_values_btn;
QAction *dock_btn; QAction *dock_btn;
QAction *reset_zoom_btn; QAction *reset_zoom_btn;
QAction *remove_all_btn; QAction *remove_all_btn;

29
tools/cabana/settings.cc
Unescape View File

@ -15,9 +15,9 @@ Settings::Settings() {
void Settings::save() { void Settings::save() {
QSettings s("settings", QSettings::IniFormat); QSettings s("settings", QSettings::IniFormat);
s.setValue("fps", fps); s.setValue("fps", fps);
s.setValue("cached_segment", cached_segment_limit); s.setValue("max_cached_minutes", max_cached_minutes);
s.setValue("chart_height", chart_height); s.setValue("chart_height", chart_height);
s.setValue("max_chart_x_range", max_chart_x_range); s.setValue("chart_range", chart_range);
s.setValue("chart_column_count", chart_column_count); s.setValue("chart_column_count", chart_column_count);
s.setValue("last_dir", last_dir); s.setValue("last_dir", last_dir);
s.setValue("window_state", window_state); s.setValue("window_state", window_state);
@ -28,9 +28,9 @@ void Settings::save() {
void Settings::load() { void Settings::load() {
QSettings s("settings", QSettings::IniFormat); QSettings s("settings", QSettings::IniFormat);
fps = s.value("fps", 10).toInt(); fps = s.value("fps", 10).toInt();
cached_segment_limit = s.value("cached_segment", 5).toInt(); max_cached_minutes = s.value("cached_minutes", 5).toInt();
chart_height = s.value("chart_height", 200).toInt(); chart_height = s.value("chart_height", 200).toInt();
max_chart_x_range = s.value("max_chart_x_range", 3 * 60).toInt(); chart_range = s.value("chart_range", 3 * 60).toInt();
chart_column_count = s.value("chart_column_count", 1).toInt(); chart_column_count = s.value("chart_column_count", 1).toInt();
last_dir = s.value("last_dir", QDir::homePath()).toString(); last_dir = s.value("last_dir", QDir::homePath()).toString();
window_state = s.value("window_state").toByteArray(); window_state = s.value("window_state").toByteArray();
@ -50,23 +50,17 @@ SettingsDlg::SettingsDlg(QWidget *parent) : QDialog(parent) {
fps->setValue(settings.fps); fps->setValue(settings.fps);
form_layout->addRow("FPS", fps); form_layout->addRow("FPS", fps);
cached_segment = new QSpinBox(this); cached_minutes = new QSpinBox(this);
cached_segment->setRange(5, 60); cached_minutes->setRange(5, 60);
cached_segment->setSingleStep(1); cached_minutes->setSingleStep(1);
cached_segment->setValue(settings.cached_segment_limit); cached_minutes->setValue(settings.max_cached_minutes);
form_layout->addRow(tr("Cached segments limit"), cached_segment); form_layout->addRow(tr("Max Cached Minutes"), cached_minutes);
max_chart_x_range = new QSpinBox(this);
max_chart_x_range->setRange(3, 60);
max_chart_x_range->setSingleStep(1);
max_chart_x_range->setValue(settings.max_chart_x_range / 60);
form_layout->addRow(tr("Chart range (minutes)"), max_chart_x_range);
chart_height = new QSpinBox(this); chart_height = new QSpinBox(this);
chart_height->setRange(100, 500); chart_height->setRange(100, 500);
chart_height->setSingleStep(10); chart_height->setSingleStep(10);
chart_height->setValue(settings.chart_height); chart_height->setValue(settings.chart_height);
form_layout->addRow(tr("Chart height"), chart_height); form_layout->addRow(tr("Chart Height"), chart_height);
auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel); auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
form_layout->addRow(buttonBox); form_layout->addRow(buttonBox);
@ -78,9 +72,8 @@ SettingsDlg::SettingsDlg(QWidget *parent) : QDialog(parent) {
void SettingsDlg::save() { void SettingsDlg::save() {
settings.fps = fps->value(); settings.fps = fps->value();
settings.cached_segment_limit = cached_segment->value(); settings.max_cached_minutes = cached_minutes->value();
settings.chart_height = chart_height->value(); settings.chart_height = chart_height->value();
settings.max_chart_x_range = max_chart_x_range->value() * 60;
settings.save(); settings.save();
accept(); accept();
emit settings.changed(); emit settings.changed();

7
tools/cabana/settings.h
Unescape View File

@ -14,10 +14,10 @@ public:
void load(); void load();
int fps = 10; int fps = 10;
int cached_segment_limit = 5; int max_cached_minutes = 5;
int chart_height = 200; int chart_height = 200;
int chart_column_count = 1; int chart_column_count = 1;
int max_chart_x_range = 3 * 60; // 3 minutes int chart_range = 3 * 60; // e minutes
QString last_dir; QString last_dir;
QByteArray geometry; QByteArray geometry;
QByteArray video_splitter_state; QByteArray video_splitter_state;
@ -34,9 +34,8 @@ public:
SettingsDlg(QWidget *parent); SettingsDlg(QWidget *parent);
void save(); void save();
QSpinBox *fps; QSpinBox *fps;
QSpinBox *cached_segment; QSpinBox *cached_minutes;
QSpinBox *chart_height; QSpinBox *chart_height;
QSpinBox *max_chart_x_range;
}; };
extern Settings settings; extern Settings settings;

2
tools/cabana/streams/livestream.h
Unescape View File

@ -17,7 +17,7 @@ public:
protected: protected:
void streamThread(); void streamThread();
void updateCachedNS() { cache_ns = (settings.cached_segment_limit * 60) * 1e9; } void updateCachedNS() { cache_ns = (settings.max_cached_minutes * 60) * 1e9; }
mutable std::mutex lock; mutable std::mutex lock;
mutable std::vector<Event *> events_vector; mutable std::vector<Event *> events_vector;

4
tools/cabana/streams/replaystream.cc
Unescape View File

@ -4,7 +4,7 @@
ReplayStream::ReplayStream(QObject *parent) : AbstractStream(parent, false) { ReplayStream::ReplayStream(QObject *parent) : AbstractStream(parent, false) {
QObject::connect(&settings, &Settings::changed, [this]() { QObject::connect(&settings, &Settings::changed, [this]() {
if (replay) replay->setSegmentCacheLimit(settings.cached_segment_limit); if (replay) replay->setSegmentCacheLimit(settings.max_cached_minutes);
}); });
} }
@ -18,7 +18,7 @@ static bool event_filter(const Event *e, void *opaque) {
bool ReplayStream::loadRoute(const QString &route, const QString &data_dir, uint32_t replay_flags) { bool ReplayStream::loadRoute(const QString &route, const QString &data_dir, uint32_t replay_flags) {
replay = new Replay(route, {"can", "roadEncodeIdx", "wideRoadEncodeIdx", "carParams"}, {}, nullptr, replay_flags, data_dir, this); replay = new Replay(route, {"can", "roadEncodeIdx", "wideRoadEncodeIdx", "carParams"}, {}, nullptr, replay_flags, data_dir, this);
replay->setSegmentCacheLimit(settings.cached_segment_limit); replay->setSegmentCacheLimit(settings.max_cached_minutes);
replay->installEventFilter(event_filter, this); replay->installEventFilter(event_filter, this);
QObject::connect(replay, &Replay::seekedTo, this, &AbstractStream::seekedTo); QObject::connect(replay, &Replay::seekedTo, this, &AbstractStream::seekedTo);
QObject::connect(replay, &Replay::segmentsMerged, this, &AbstractStream::eventsMerged); QObject::connect(replay, &Replay::segmentsMerged, this, &AbstractStream::eventsMerged);

Write Preview
Loading…
Cancel
Save