autonomy_datasets_rviz_plugins::PlaybackPanel Class Reference

#include <playback_panel.hpp>

Inheritance diagram for autonomy_datasets_rviz_plugins::PlaybackPanel:

Signals
void	requestFinished (const QString &position, const QString &status, bool success)
	Reports the outcome of a sample request from the thread that received the response.

Public Member Functions
	PlaybackPanel (QWidget *parent=nullptr)
	Creates the panel and its widgets, without connecting to a service yet.
	~PlaybackPanel () override
	Destroys the panel, dropping the service client before the RViz node goes away.
	PlaybackPanel (const PlaybackPanel &)=delete
	Copy construction is disabled because the panel owns Qt and ROS resources.
PlaybackPanel &	operator= (const PlaybackPanel &)=delete
	Copy assignment is disabled because the panel owns Qt and ROS resources.
	PlaybackPanel (PlaybackPanel &&)=delete
	Move construction is disabled because RViz owns the panel lifecycle.
PlaybackPanel &	operator= (PlaybackPanel &&)=delete
	Move assignment is disabled because RViz owns the panel lifecycle.
void	onInitialize () override
	Picks up the ROS node of RViz and creates the client for the configured service.
void	load (const rviz_common::Config &config) override
	Restores the service name and step size stored in the RViz configuration.
void	save (rviz_common::Config config) const override
	Stores the service name and step size in the RViz configuration.

Private Member Functions
void	onServiceNameChanged ()
	Re-creates the service client after the service name has been edited.
void	onPauseClicked ()
	Requests no sample at all, which stops the playback at the current sample.
void	onStepClicked ()
	Requests the next samples, which advances the playback by the configured step size.
void	onSkipClicked ()
	Requests the entered sample IDs, which skips the playback ahead to them.
void	onPlayClicked ()
	Requests all remaining samples, which runs the playback to the end of the dataset.
void	updateAvailability ()
	Tracks whether the service is available and reflects it in the panel.
void	applyRequestResult (const QString &position, const QString &status, bool success)
	Shows the outcome of a sample request and re-enables the controls.
bool	eventFilter (QObject *watched, QEvent *event) override
	Re-shortens the reported texts whenever one of the labels showing them is resized.
void	setupUi ()
	Creates the widgets of the panel and connects them to their handlers.
void	showPosition (const QString &text)
	Reports which sample the dataset node published last.
void	showStatus (const QString &text)
	Reports what the panel is waiting for or what a request resulted in.
void	createClient ()
	Creates the service client for the service name currently entered in the panel.
void	sendRequest (uint8_t mode, uint64_t num_samples, const std::vector< uint64_t > &sample_ids, const QString &pending_status)
	Sends a sample request and reports its response through requestFinished().
void	updateControlState ()
	Enables the controls that may be used while no request is being processed.
std::vector< uint64_t >	parseSampleIds (QString *error) const
	Reads the sample IDs entered in the panel.

Static Private Member Functions
static void	showElided (QLabel *label, const QString &text)
	Shows as much of a text as fits into a label and offers all of it as its tooltip.
static QString	describePosition (const autonomy_datasets_msgs::srv::RequestSamples::Response &response)
	Describes the sample a response reports as published last.

Private Attributes
QLineEdit *	service_name_edit_ {nullptr}
	Name of the request_samples service of the dataset node to control.
QSpinBox *	step_size_spin_ {nullptr}
	Number of samples a step advances the playback by.
QLineEdit *	sample_ids_edit_ {nullptr}
	Sample IDs to skip ahead to.
QPushButton *	pause_button_ {nullptr}
	Stops the playback at the current sample.
QPushButton *	step_button_ {nullptr}
	Advances the playback by the configured step size.
QPushButton *	skip_button_ {nullptr}
	Skips the playback ahead to the entered sample IDs.
QPushButton *	play_button_ {nullptr}
	Runs the playback to the end of the dataset.
QLabel *	position_label_ {nullptr}
	Sample the dataset node published last.
QLabel *	status_label_ {nullptr}
	Outcome of the last request, or why no request can be sent.
QTimer *	availability_timer_ {nullptr}
	Polls whether the service is available, as the panel cannot be notified about it.
rclcpp::Node::SharedPtr	node_
	ROS node of RViz, which its executor spins.
rclcpp::Client< autonomy_datasets_msgs::srv::RequestSamples >::SharedPtr	client_
	Client of the request_samples service of the dataset node.
bool	request_in_flight_ {false}
	Whether a request has been sent whose response has not arrived yet.
bool	service_available_ {false}
	Whether the service was available the last time it was polled.
QString	position_text_
	Full text reported by position_label_, of which only what fits is shown.
QString	status_text_
	Full text reported by status_label_, of which only what fits is shown.

Detailed Description

Definition at line 33 of file playback_panel.hpp.

Constructor & Destructor Documentation

PlaybackPanel() [1/3]

autonomy_datasets_rviz_plugins::PlaybackPanel::PlaybackPanel ( QWidget * parent = nullptr )

explicit

Creates the panel and its widgets, without connecting to a service yet.

Parameters

parent

widget taking ownership of the panel, as usual for Qt widgets

Definition at line 37 of file playback_panel.cpp.

: rviz_common::Panel(parent) { setupUi(); }

~PlaybackPanel()

autonomy_datasets_rviz_plugins::PlaybackPanel::~PlaybackPanel ( )

override

Destroys the panel, dropping the service client before the RViz node goes away.

Definition at line 39 of file playback_panel.cpp.

                              {
  // Drops the pending request together with its callback, which would otherwise report into a
  // panel that no longer exists. RViz spins its node from the GUI thread that also destroys the
  // panel, so no response can be in the middle of being delivered while this runs.
  client_.reset();
}

PlaybackPanel() [2/3]

autonomy_datasets_rviz_plugins::PlaybackPanel::PlaybackPanel ( const PlaybackPanel & )

delete

Copy construction is disabled because the panel owns Qt and ROS resources.

PlaybackPanel() [3/3]

autonomy_datasets_rviz_plugins::PlaybackPanel::PlaybackPanel ( PlaybackPanel && )

delete

Move construction is disabled because RViz owns the panel lifecycle.

Member Function Documentation

applyRequestResult()

void autonomy_datasets_rviz_plugins::PlaybackPanel::applyRequestResult ( const QString & position, const QString & status, bool success )

private

Shows the outcome of a sample request and re-enables the controls.

Only ever called on the GUI thread, as the response of a request may reach the panel on whichever thread the executor of RViz runs on.

Parameters

position	description of the sample the dataset node published last
status	description of the outcome, as reported by the service
success	whether all requested samples have been published

Definition at line 330 of file playback_panel.cpp.

                                                                                                   {
  request_in_flight_ = false;
  if (!position.isEmpty()) {
    showPosition(position);
  }
  showStatus(success ? tr("OK - %1").arg(status) : tr("Failed - %1").arg(status));
  updateControlState();
}

createClient()

void autonomy_datasets_rviz_plugins::PlaybackPanel::createClient ( )

private

Creates the service client for the service name currently entered in the panel.

Definition at line 196 of file playback_panel.cpp.

                                 {
  const QString service_name = service_name_edit_->text().trimmed();
  if (node_ == nullptr || service_name.isEmpty()) {
    client_.reset();
    updateAvailability();
    return;
  }
  client_ = node_->create_client<RequestSamples>(service_name.toStdString());
  service_available_ = false;
  updateAvailability();
}

describePosition()

QString autonomy_datasets_rviz_plugins::PlaybackPanel::describePosition ( const autonomy_datasets_msgs::srv::RequestSamples::Response & response )

staticprivate

Describes the sample a response reports as published last.

Parameters

response

response of the sample request

Returns

description of the last published sample, or a placeholder if none was published

Definition at line 317 of file playback_panel.cpp.

                                                                              {
  if (response.published_sample_ids.empty()) {
    return {};
  }
  const uint64_t sample_id = response.published_sample_ids.back();
  if (response.published_scene_ids.size() != response.published_sample_ids.size()) {
    return tr("Sample %1").arg(static_cast<qulonglong>(sample_id));
  }
  return tr("Sample %1 of scene '%2'")
      .arg(static_cast<qulonglong>(sample_id))
      .arg(QString::fromStdString(response.published_scene_ids.back()));
}

eventFilter()

bool autonomy_datasets_rviz_plugins::PlaybackPanel::eventFilter ( QObject * watched, QEvent * event )

overrideprivate

Re-shortens the reported texts whenever one of the labels showing them is resized.

Parameters

watched	object the event is delivered to
event	event delivered to the watched object

Returns

whether the event has been handled and is not to be delivered any further

Definition at line 137 of file playback_panel.cpp.

                                                               {
  if (event->type() == QEvent::Resize) {
    if (watched == position_label_) {
      showElided(position_label_, position_text_);
    } else if (watched == status_label_) {
      showElided(status_label_, status_text_);
    }
  }
  return rviz_common::Panel::eventFilter(watched, event);
}

load()

void autonomy_datasets_rviz_plugins::PlaybackPanel::load ( const rviz_common::Config & config )

override

Restores the service name and step size stored in the RViz configuration.

Parameters

config

RViz configuration to read the panel settings from

Definition at line 174 of file playback_panel.cpp.

                                                        {
  rviz_common::Panel::load(config);
 
  QString service_name;
  if (config.mapGetString("ServiceName", &service_name) && !service_name.isEmpty()) {
    service_name_edit_->setText(service_name);
  }
  float step_size = 0.0F;
  if (config.mapGetFloat("StepSize", &step_size) && step_size >= 1.0F) {
    step_size_spin_->setValue(static_cast<int>(step_size));
  }
  if (node_ != nullptr) {
    createClient();
  }
}

onInitialize()

void autonomy_datasets_rviz_plugins::PlaybackPanel::onInitialize ( )

override

Picks up the ROS node of RViz and creates the client for the configured service.

Definition at line 168 of file playback_panel.cpp.

                                 {
  node_ = getDisplayContext()->getRosNodeAbstraction().lock()->get_raw_node();
  createClient();
  availability_timer_->start(kAvailabilityPollIntervalMs);
}

onPauseClicked()

void autonomy_datasets_rviz_plugins::PlaybackPanel::onPauseClicked ( )

private

Requests no sample at all, which stops the playback at the current sample.

Definition at line 243 of file playback_panel.cpp.

                                   {
  // A request for no sample at all takes control of the playback without publishing anything,
  // which leaves the playback waiting for the next request
  sendRequest(RequestSamples::Request::MODE_NEXT_SAMPLES, 0, {}, tr("Pausing playback..."));
}

onPlayClicked()

void autonomy_datasets_rviz_plugins::PlaybackPanel::onPlayClicked ( )

private

Requests all remaining samples, which runs the playback to the end of the dataset.

Definition at line 270 of file playback_panel.cpp.

                                  {
  sendRequest(RequestSamples::Request::MODE_ALL_SAMPLES, 0, {}, tr("Publishing all remaining samples..."));
}

onServiceNameChanged()

void autonomy_datasets_rviz_plugins::PlaybackPanel::onServiceNameChanged ( )

private

Re-creates the service client after the service name has been edited.

Definition at line 208 of file playback_panel.cpp.

                                         {
  createClient();
  Q_EMIT configChanged();
}

onSkipClicked()

void autonomy_datasets_rviz_plugins::PlaybackPanel::onSkipClicked ( )

private

Requests the entered sample IDs, which skips the playback ahead to them.

Definition at line 255 of file playback_panel.cpp.

                                  {
  QString error;
  const std::vector<uint64_t> sample_ids = parseSampleIds(&error);
  if (!error.isEmpty()) {
    showStatus(error);
    return;
  }
  if (sample_ids.empty()) {
    showStatus(tr("Enter the ID of the sample to skip to"));
    return;
  }
  sendRequest(RequestSamples::Request::MODE_SAMPLE_IDS, 0, sample_ids,
              tr("Skipping ahead to %1 sample(s)...").arg(static_cast<qulonglong>(sample_ids.size())));
}

onStepClicked()

void autonomy_datasets_rviz_plugins::PlaybackPanel::onStepClicked ( )

private

Requests the next samples, which advances the playback by the configured step size.

Definition at line 249 of file playback_panel.cpp.

                                  {
  const auto num_samples = static_cast<uint64_t>(step_size_spin_->value());
  sendRequest(RequestSamples::Request::MODE_NEXT_SAMPLES, num_samples, {},
              tr("Publishing the next %1 sample(s)...").arg(static_cast<qulonglong>(num_samples)));
}

operator=() [1/2]

PlaybackPanel & autonomy_datasets_rviz_plugins::PlaybackPanel::operator= ( const PlaybackPanel & )

delete

Copy assignment is disabled because the panel owns Qt and ROS resources.

operator=() [2/2]

PlaybackPanel & autonomy_datasets_rviz_plugins::PlaybackPanel::operator= ( PlaybackPanel && )

delete

Move assignment is disabled because RViz owns the panel lifecycle.

parseSampleIds()

std::vector< uint64_t > autonomy_datasets_rviz_plugins::PlaybackPanel::parseSampleIds ( QString * error ) const

private

Reads the sample IDs entered in the panel.

Parameters

error

set to a description of the first malformed entry, if there is one

Returns

sample IDs in the order they were entered, empty if an entry is malformed

Definition at line 274 of file playback_panel.cpp.

                                                                      {
  std::vector<uint64_t> sample_ids;
  const QStringList entries = sample_ids_edit_->text().split(QRegularExpression("[,;\\s]+"), Qt::SkipEmptyParts);
  for (const QString& entry : entries) {
    bool valid = false;
    const qulonglong sample_id = entry.toULongLong(&valid);
    if (!valid) {
      *error = tr("'%1' is not a sample ID").arg(entry);
      return {};
    }
    sample_ids.push_back(static_cast<uint64_t>(sample_id));
  }
  return sample_ids;
}

requestFinished

void autonomy_datasets_rviz_plugins::PlaybackPanel::requestFinished ( const QString & position, const QString & status, bool success )

signal

Reports the outcome of a sample request from the thread that received the response.

Connected to applyRequestResult() as a queued connection, so that the widgets are only ever touched by the GUI thread, no matter which thread the executor of RViz answers the request on. Qt drops the queued call if the panel is closed before it is delivered.

Parameters

position	description of the sample the dataset node published last
status	description of the outcome, as reported by the service
success	whether all requested samples have been published

save()

void autonomy_datasets_rviz_plugins::PlaybackPanel::save ( rviz_common::Config config ) const

override

Stores the service name and step size in the RViz configuration.

Parameters

config

RViz configuration to write the panel settings to

Definition at line 190 of file playback_panel.cpp.

                                                       {
  rviz_common::Panel::save(config);
  config.mapSetValue("ServiceName", service_name_edit_->text());
  config.mapSetValue("StepSize", step_size_spin_->value());
}

sendRequest()

void autonomy_datasets_rviz_plugins::PlaybackPanel::sendRequest ( uint8_t mode, uint64_t num_samples, const std::vector< uint64_t > & sample_ids, const QString & pending_status )

private

Sends a sample request and reports its response through requestFinished().

Parameters

mode	requested playback mode, one of the MODE_* constants of the service
num_samples	number of samples to publish in MODE_NEXT_SAMPLES
sample_ids	IDs of the samples to publish in MODE_SAMPLE_IDS
pending_status	description of the request, shown while it is being processed

Definition at line 289 of file playback_panel.cpp.

                                                               {
  if (client_ == nullptr || !client_->service_is_ready()) {
    showStatus(tr("Service '%1' is not available").arg(service_name_edit_->text().trimmed()));
    return;
  }
 
  auto request = std::make_shared<RequestSamples::Request>();
  request->mode = mode;
  request->num_samples = num_samples;
  request->sample_ids = sample_ids;
 
  request_in_flight_ = true;
  showStatus(pending_status);
  updateControlState();
 
  client_->async_send_request(request, [this](rclcpp::Client<RequestSamples>::SharedFuture future) {
    const auto response = future.get();
    QString status = QString::fromStdString(response->message);
    if (response->end_of_dataset) {
      status += tr("; the dataset has ended");
    }
    Q_EMIT requestFinished(describePosition(*response), status, response->success);
  });
}

setupUi()

void autonomy_datasets_rviz_plugins::PlaybackPanel::setupUi ( )

private

Creates the widgets of the panel and connects them to their handlers.

Definition at line 46 of file playback_panel.cpp.

                            {
  // NOLINTBEGIN(cppcoreguidelines-owning-memory) Qt widgets are owned by their parent widget
  service_name_edit_ = new QLineEdit(QString::fromUtf8(kDefaultServiceName), this);
  service_name_edit_->setToolTip(
      tr("Name of the 'request_samples' service of the dataset node, as reported by 'ros2 service list'"));
 
  auto* service_layout = new QFormLayout();
  service_layout->addRow(tr("Service"), service_name_edit_);
 
  pause_button_ = new QPushButton(tr("Pause"), this);
  pause_button_->setToolTip(tr("Stop the playback at the current sample, without publishing another one"));
  play_button_ = new QPushButton(tr("Play to End"), this);
  play_button_->setToolTip(
      tr("Publish all remaining samples of the dataset.\n"
         "The dataset node answers this request only once the dataset ends, so the playback cannot be paused again "
         "until then."));
 
  auto* transport_layout = new QHBoxLayout();
  transport_layout->addWidget(pause_button_);
  transport_layout->addWidget(play_button_);
 
  step_size_spin_ = new QSpinBox(this);
  step_size_spin_->setRange(1, kMaximumStepSize);
  step_size_spin_->setValue(1);
  step_size_spin_->setToolTip(tr("Number of samples a step publishes"));
  step_button_ = new QPushButton(tr("Step"), this);
  step_button_->setToolTip(tr("Publish the next samples, whichever they are"));
 
  auto* step_layout = new QHBoxLayout();
  step_layout->addWidget(step_size_spin_);
  step_layout->addWidget(new QLabel(tr("sample(s)"), this));
  step_layout->addStretch();
  step_layout->addWidget(step_button_);
 
  sample_ids_edit_ = new QLineEdit(this);
  sample_ids_edit_->setPlaceholderText(tr("e.g. 120 or 10, 20, 30"));
  sample_ids_edit_->setToolTip(
      tr("IDs of the samples to publish, skipping every sample in between.\n"
         "The playback is forward-only, so it cannot go back to a sample it has already passed."));
  skip_button_ = new QPushButton(tr("Skip To"), this);
  skip_button_->setToolTip(tr("Skip ahead to the entered samples"));
 
  auto* skip_layout = new QHBoxLayout();
  skip_layout->addWidget(sample_ids_edit_);
  skip_layout->addWidget(skip_button_);
 
  auto* separator = new QFrame(this);
  separator->setFrameShape(QFrame::HLine);
  separator->setFrameShadow(QFrame::Sunken);
 
  position_label_ = new QLabel(this);
  status_label_ = new QLabel(this);
  for (QLabel* label : {position_label_, status_label_}) {
    // The layout gives the labels whatever width the controls above them need, instead of the
    // labels asking for the width their text would take
    label->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Preferred);
    label->installEventFilter(this);
  }
 
  auto* layout = new QVBoxLayout();
  layout->addLayout(service_layout);
  layout->addLayout(transport_layout);
  layout->addLayout(step_layout);
  layout->addLayout(skip_layout);
  layout->addWidget(separator);
  layout->addWidget(position_label_);
  layout->addWidget(status_label_);
  layout->addStretch();
  setLayout(layout);
 
  availability_timer_ = new QTimer(this);
  // NOLINTEND(cppcoreguidelines-owning-memory)
 
  connect(service_name_edit_, &QLineEdit::editingFinished, this, &PlaybackPanel::onServiceNameChanged);
  connect(pause_button_, &QPushButton::clicked, this, &PlaybackPanel::onPauseClicked);
  connect(play_button_, &QPushButton::clicked, this, &PlaybackPanel::onPlayClicked);
  connect(step_button_, &QPushButton::clicked, this, &PlaybackPanel::onStepClicked);
  connect(skip_button_, &QPushButton::clicked, this, &PlaybackPanel::onSkipClicked);
  connect(sample_ids_edit_, &QLineEdit::returnPressed, this, &PlaybackPanel::onSkipClicked);
  connect(availability_timer_, &QTimer::timeout, this, &PlaybackPanel::updateAvailability);
  connect(step_size_spin_, QOverload<int>::of(&QSpinBox::valueChanged), this, &PlaybackPanel::configChanged);
 
  // The response of a request may reach the panel on whichever thread the executor of RViz runs
  // on, so the widgets are updated through a queued connection instead of from the callback.
  connect(this, &PlaybackPanel::requestFinished, this, &PlaybackPanel::applyRequestResult, Qt::QueuedConnection);
 
  showPosition(tr("No sample published yet"));
  showStatus(tr("Not connected to a dataset node yet"));
  updateControlState();
}

showElided()

void autonomy_datasets_rviz_plugins::PlaybackPanel::showElided ( QLabel * label, const QString & text )

staticprivate

Shows as much of a text as fits into a label and offers all of it as its tooltip.

The panel is docked beside the render window of RViz, where a scene ID or a message of the service would widen it far beyond the width its controls need.

Parameters

label	label to show the text in
text	text to show, shortened at its end where it does not fit

Definition at line 158 of file playback_panel.cpp.

                                                                 {
  const QString shown = label->fontMetrics().elidedText(text, Qt::ElideRight, label->contentsRect().width());
  if (shown != label->text()) {
    // Guards against a resize that the new text triggers in turn
    label->setText(shown);
  }
  // Marked up as rich text, so that a long text is wrapped over several lines of the tooltip
  label->setToolTip(text.isEmpty() ? QString() : QString("<qt>%1</qt>").arg(text.toHtmlEscaped()));
}

showPosition()

void autonomy_datasets_rviz_plugins::PlaybackPanel::showPosition ( const QString & text )

private

Reports which sample the dataset node published last.

Parameters

text	description of the sample

Definition at line 148 of file playback_panel.cpp.

                                                    {
  position_text_ = text;
  showElided(position_label_, position_text_);
}

showStatus()

void autonomy_datasets_rviz_plugins::PlaybackPanel::showStatus ( const QString & text )

private

Reports what the panel is waiting for or what a request resulted in.

Parameters

text	description of the state or of the outcome

Definition at line 153 of file playback_panel.cpp.

                                                  {
  status_text_ = text;
  showElided(status_label_, status_text_);
}

updateAvailability()

void autonomy_datasets_rviz_plugins::PlaybackPanel::updateAvailability ( )

private

Tracks whether the service is available and reflects it in the panel.

Definition at line 213 of file playback_panel.cpp.

                                       {
  const bool available = client_ != nullptr && client_->service_is_ready();
  if (available == service_available_) {
    updateControlState();
    return;
  }
  service_available_ = available;
 
  if (!available && request_in_flight_) {
    // The node answering the request is gone, so its response will never arrive
    request_in_flight_ = false;
    showStatus(tr("The dataset node disappeared while it was processing the request"));
  } else if (!available) {
    showStatus(tr("Waiting for service '%1'").arg(service_name_edit_->text().trimmed()));
  } else if (!request_in_flight_) {
    showStatus(tr("Connected to '%1'").arg(service_name_edit_->text().trimmed()));
  }
  updateControlState();
}

updateControlState()

void autonomy_datasets_rviz_plugins::PlaybackPanel::updateControlState ( )

private

Enables the controls that may be used while no request is being processed.

Definition at line 233 of file playback_panel.cpp.

                                       {
  const bool ready = service_available_ && !request_in_flight_;
  pause_button_->setEnabled(ready);
  play_button_->setEnabled(ready);
  step_button_->setEnabled(ready);
  skip_button_->setEnabled(ready);
  step_size_spin_->setEnabled(ready);
  sample_ids_edit_->setEnabled(ready);
}

Member Data Documentation

availability_timer_

QTimer* autonomy_datasets_rviz_plugins::PlaybackPanel::availability_timer_ {nullptr}

private

Polls whether the service is available, as the panel cannot be notified about it.

Definition at line 241 of file playback_panel.hpp.

{nullptr};

client_

rclcpp::Client<autonomy_datasets_msgs::srv::RequestSamples>::SharedPtr autonomy_datasets_rviz_plugins::PlaybackPanel::client_

private

Client of the request_samples service of the dataset node.

Definition at line 246 of file playback_panel.hpp.

node_

rclcpp::Node::SharedPtr autonomy_datasets_rviz_plugins::PlaybackPanel::node_

private

ROS node of RViz, which its executor spins.

Definition at line 244 of file playback_panel.hpp.

pause_button_

QPushButton* autonomy_datasets_rviz_plugins::PlaybackPanel::pause_button_ {nullptr}

private

Stops the playback at the current sample.

Definition at line 229 of file playback_panel.hpp.

{nullptr};

play_button_

QPushButton* autonomy_datasets_rviz_plugins::PlaybackPanel::play_button_ {nullptr}

private

Runs the playback to the end of the dataset.

Definition at line 235 of file playback_panel.hpp.

{nullptr};

position_label_

QLabel* autonomy_datasets_rviz_plugins::PlaybackPanel::position_label_ {nullptr}

private

Sample the dataset node published last.

Definition at line 237 of file playback_panel.hpp.

{nullptr};

position_text_

QString autonomy_datasets_rviz_plugins::PlaybackPanel::position_text_

private

Full text reported by position_label_, of which only what fits is shown.

Definition at line 252 of file playback_panel.hpp.

request_in_flight_

bool autonomy_datasets_rviz_plugins::PlaybackPanel::request_in_flight_ {false}

private

Whether a request has been sent whose response has not arrived yet.

Definition at line 248 of file playback_panel.hpp.

{false};

sample_ids_edit_

QLineEdit* autonomy_datasets_rviz_plugins::PlaybackPanel::sample_ids_edit_ {nullptr}

private

Sample IDs to skip ahead to.

Definition at line 227 of file playback_panel.hpp.

{nullptr};

service_available_

bool autonomy_datasets_rviz_plugins::PlaybackPanel::service_available_ {false}

private

Whether the service was available the last time it was polled.

Definition at line 250 of file playback_panel.hpp.

{false};

service_name_edit_

QLineEdit* autonomy_datasets_rviz_plugins::PlaybackPanel::service_name_edit_ {nullptr}

private

Name of the request_samples service of the dataset node to control.

Definition at line 223 of file playback_panel.hpp.

{nullptr};

skip_button_

QPushButton* autonomy_datasets_rviz_plugins::PlaybackPanel::skip_button_ {nullptr}

private

Skips the playback ahead to the entered sample IDs.

Definition at line 233 of file playback_panel.hpp.

{nullptr};

status_label_

QLabel* autonomy_datasets_rviz_plugins::PlaybackPanel::status_label_ {nullptr}

private

Outcome of the last request, or why no request can be sent.

Definition at line 239 of file playback_panel.hpp.

{nullptr};

status_text_

QString autonomy_datasets_rviz_plugins::PlaybackPanel::status_text_

private

Full text reported by status_label_, of which only what fits is shown.

Definition at line 254 of file playback_panel.hpp.

step_button_

QPushButton* autonomy_datasets_rviz_plugins::PlaybackPanel::step_button_ {nullptr}

private

Advances the playback by the configured step size.

Definition at line 231 of file playback_panel.hpp.

{nullptr};

step_size_spin_

QSpinBox* autonomy_datasets_rviz_plugins::PlaybackPanel::step_size_spin_ {nullptr}

private

Number of samples a step advances the playback by.

Definition at line 225 of file playback_panel.hpp.

{nullptr};

---

The documentation for this class was generated from the following files:

• autonomy_datasets_rviz_plugins/include/autonomy_datasets_rviz_plugins/playback_panel.hpp
• autonomy_datasets_rviz_plugins/src/playback_panel.cpp