robot_state_display.cpp
Go to the documentation of this file.
1 /*********************************************************************
2  * Software License Agreement (BSD License)
3  *
4  * Copyright (c) 2008, Willow Garage, Inc.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * * Redistributions of source code must retain the above copyright
12  * notice, this list of conditions and the following disclaimer.
13  * * Redistributions in binary form must reproduce the above
14  * copyright notice, this list of conditions and the following
15  * disclaimer in the documentation and/or other materials provided
16  * with the distribution.
17  * * Neither the name of Willow Garage nor the names of its
18  * contributors may be used to endorse or promote products derived
19  * from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32  * POSSIBILITY OF SUCH DAMAGE.
33  *********************************************************************/
34 
35 /* Author: Ioan Sucan */
36 
40 
42 #include <rviz/robot/robot.h>
43 #include <rviz/robot/robot_link.h>
44 
51 #include <rviz/display_context.h>
52 #include <rviz/frame_manager.h>
53 
54 #include <OgreSceneManager.h>
55 #include <OgreSceneNode.h>
56 
57 #include <memory>
58 
59 namespace moveit_rviz_plugin
60 {
61 // ******************************************************************************************
62 // Base class contructor
63 // ******************************************************************************************
64 RobotStateDisplay::RobotStateDisplay() : Display(), update_state_(false)
65 {
66  robot_description_property_ =
67  new rviz::StringProperty("Robot Description", "robot_description",
68  "The name of the ROS parameter where the URDF for the robot is loaded", this,
69  SLOT(changedRobotDescription()), this);
70 
71  robot_state_topic_property_ =
72  new rviz::RosTopicProperty("Robot State Topic", "display_robot_state",
73  ros::message_traits::datatype<moveit_msgs::DisplayRobotState>(),
74  "The topic on which the moveit_msgs::DisplayRobotState messages are received", this,
75  SLOT(changedRobotStateTopic()), this);
76 
77  // Planning scene category -------------------------------------------------------------------------------------------
78  root_link_name_property_ =
79  new rviz::StringProperty("Robot Root Link", "", "Shows the name of the root link for the robot model", this,
80  SLOT(changedRootLinkName()), this);
81  root_link_name_property_->setReadOnly(true);
82 
83  robot_alpha_property_ = new rviz::FloatProperty("Robot Alpha", 1.0f, "Specifies the alpha for the robot links", this,
84  SLOT(changedRobotSceneAlpha()), this);
85  robot_alpha_property_->setMin(0.0);
86  robot_alpha_property_->setMax(1.0);
87 
88  attached_body_color_property_ =
89  new rviz::ColorProperty("Attached Body Color", QColor(150, 50, 150), "The color for the attached bodies", this,
90  SLOT(changedAttachedBodyColor()), this);
91 
92  enable_link_highlight_ =
93  new rviz::BoolProperty("Show Highlights", true, "Specifies whether link highlighting is enabled", this,
94  SLOT(changedEnableLinkHighlight()), this);
95  enable_visual_visible_ =
96  new rviz::BoolProperty("Visual Enabled", true, "Whether to display the visual representation of the robot.", this,
97  SLOT(changedEnableVisualVisible()), this);
98  enable_collision_visible_ = new rviz::BoolProperty("Collision Enabled", false,
99  "Whether to display the collision representation of the robot.",
100  this, SLOT(changedEnableCollisionVisible()), this);
101 
102  show_all_links_ = new rviz::BoolProperty("Show All Links", true, "Toggle all links visibility on or off.", this,
103  SLOT(changedAllLinks()), this);
104 }
105 
106 // ******************************************************************************************
107 // Deconstructor
108 // ******************************************************************************************
110 
112 {
113  Display::onInitialize();
114  robot_ = std::make_shared<RobotStateVisualization>(scene_node_, context_, "Robot State", this);
117  robot_->setVisible(false);
118 }
119 
121 {
122  robot_->clear();
123  rdf_loader_.reset();
124  Display::reset();
125  if (isEnabled())
126  onEnable();
127 }
128 
130 {
131  Property* links_prop = subProp("Links");
132  QVariant value(show_all_links_->getBool());
133 
134  for (int i = 0; i < links_prop->numChildren(); ++i)
135  {
136  Property* link_prop = links_prop->childAt(i);
137  link_prop->setValue(value);
138  }
139 }
140 
141 void RobotStateDisplay::setHighlight(const std::string& link_name, const std_msgs::ColorRGBA& color)
142 {
143  rviz::RobotLink* link = robot_->getRobot().getLink(link_name);
144  if (link)
145  {
146  link->setColor(color.r, color.g, color.b);
147  link->setRobotAlpha(color.a * robot_alpha_property_->getFloat());
148  }
149 }
150 
151 void RobotStateDisplay::unsetHighlight(const std::string& link_name)
152 {
153  rviz::RobotLink* link = robot_->getRobot().getLink(link_name);
154  if (link)
155  {
156  link->unsetColor();
158  }
159 }
160 
162 {
164  {
165  for (std::pair<const std::string, std_msgs::ColorRGBA>& highlight : highlights_)
166  {
167  setHighlight(highlight.first, highlight.second);
168  }
169  }
170  else
171  {
172  for (std::pair<const std::string, std_msgs::ColorRGBA>& highlight : highlights_)
173  {
174  unsetHighlight(highlight.first);
175  }
176  }
177 }
178 
180 {
181  robot_->setVisualVisible(enable_visual_visible_->getBool());
182 }
183 
185 {
186  robot_->setCollisionVisible(enable_collision_visible_->getBool());
187 }
188 
189 static bool operator!=(const std_msgs::ColorRGBA& a, const std_msgs::ColorRGBA& b)
190 {
191  return a.r != b.r || a.g != b.g || a.b != b.b || a.a != b.a;
192 }
193 
194 void RobotStateDisplay::setRobotHighlights(const moveit_msgs::DisplayRobotState::_highlight_links_type& highlight_links)
195 {
196  if (highlight_links.empty() && highlights_.empty())
197  return;
198 
199  std::map<std::string, std_msgs::ColorRGBA> highlights;
200  for (const moveit_msgs::ObjectColor& highlight_link : highlight_links)
201  {
202  highlights[highlight_link.id] = highlight_link.color;
203  }
204 
206  {
207  std::map<std::string, std_msgs::ColorRGBA>::iterator ho = highlights_.begin();
208  std::map<std::string, std_msgs::ColorRGBA>::iterator hn = highlights.begin();
209  while (ho != highlights_.end() || hn != highlights.end())
210  {
211  if (ho == highlights_.end())
212  {
213  setHighlight(hn->first, hn->second);
214  ++hn;
215  }
216  else if (hn == highlights.end())
217  {
218  unsetHighlight(ho->first);
219  ++ho;
220  }
221  else if (hn->first < ho->first)
222  {
223  setHighlight(hn->first, hn->second);
224  ++hn;
225  }
226  else if (hn->first > ho->first)
227  {
228  unsetHighlight(ho->first);
229  ++ho;
230  }
231  else if (hn->second != ho->second)
232  {
233  setHighlight(hn->first, hn->second);
234  ++ho;
235  ++hn;
236  }
237  else
238  {
239  ++ho;
240  ++hn;
241  }
242  }
243  }
244 
245  swap(highlights, highlights_);
246 }
247 
249 {
250  if (robot_)
251  {
252  QColor color = attached_body_color_property_->getColor();
253  std_msgs::ColorRGBA color_msg;
254  color_msg.r = color.redF();
255  color_msg.g = color.greenF();
256  color_msg.b = color.blueF();
257  color_msg.a = robot_alpha_property_->getFloat();
258  robot_->setDefaultAttachedObjectColor(color_msg);
259  update_state_ = true;
260  }
261 }
262 
264 {
265  if (isEnabled())
266  reset();
267 }
268 
270 {
271 }
272 
274 {
275  if (robot_)
276  {
277  robot_->setAlpha(robot_alpha_property_->getFloat());
278  QColor color = attached_body_color_property_->getColor();
279  std_msgs::ColorRGBA color_msg;
280  color_msg.r = color.redF();
281  color_msg.g = color.greenF();
282  color_msg.b = color.blueF();
283  color_msg.a = robot_alpha_property_->getFloat();
284  robot_->setDefaultAttachedObjectColor(color_msg);
285  update_state_ = true;
286  }
287 }
288 
290 {
292 
293  // reset model to default state, we don't want to show previous messages
294  if (static_cast<bool>(robot_state_))
295  robot_state_->setToDefaultValues();
296  update_state_ = true;
297  robot_->setVisible(false);
298  setStatus(rviz::StatusProperty::Warn, "RobotState", "No msg received");
299 
302 }
303 
304 void RobotStateDisplay::newRobotStateCallback(const moveit_msgs::DisplayRobotStateConstPtr& state_msg)
305 {
306  if (!robot_model_)
307  return;
308  if (!robot_state_)
309  robot_state_ = std::make_shared<moveit::core::RobotState>(robot_model_);
310  // possibly use TF to construct a moveit::core::Transforms object to pass in to the conversion function?
311  try
312  {
313  if (!moveit::core::isEmpty(state_msg->state))
315  setRobotHighlights(state_msg->highlight_links);
316  }
317  catch (const moveit::Exception& e)
318  {
319  robot_state_->setToDefaultValues();
320  setRobotHighlights(moveit_msgs::DisplayRobotState::_highlight_links_type());
321  setStatus(rviz::StatusProperty::Error, "RobotState", e.what());
322  robot_->setVisible(false);
323  return;
324  }
325 
326  if (robot_->isVisible() != !state_msg->hide)
327  {
328  robot_->setVisible(!state_msg->hide);
329  if (robot_->isVisible())
330  setStatus(rviz::StatusProperty::Ok, "RobotState", "");
331  else
332  setStatus(rviz::StatusProperty::Warn, "RobotState", "Hidden");
333  }
334 
335  update_state_ = true;
336 }
337 
338 void RobotStateDisplay::setLinkColor(const std::string& link_name, const QColor& color)
339 {
340  setLinkColor(&robot_->getRobot(), link_name, color);
341 }
342 
343 void RobotStateDisplay::unsetLinkColor(const std::string& link_name)
344 {
345  unsetLinkColor(&robot_->getRobot(), link_name);
346 }
347 
348 void RobotStateDisplay::setVisible(bool visible)
349 {
350  robot_->setVisible(visible);
351 }
352 
353 void RobotStateDisplay::setLinkColor(rviz::Robot* robot, const std::string& link_name, const QColor& color)
354 {
355  rviz::RobotLink* link = robot->getLink(link_name);
356 
357  // Check if link exists
358  if (link)
359  link->setColor(color.redF(), color.greenF(), color.blueF());
360 }
361 
362 void RobotStateDisplay::unsetLinkColor(rviz::Robot* robot, const std::string& link_name)
363 {
364  rviz::RobotLink* link = robot->getLink(link_name);
365 
366  // Check if link exists
367  if (link)
368  link->unsetColor();
369 }
370 
371 // ******************************************************************************************
372 // Load
373 // ******************************************************************************************
375 {
376  rdf_loader_ = std::make_shared<rdf_loader::RDFLoader>(robot_description_property_->getStdString());
377 
378  if (rdf_loader_->getURDF())
379  {
380  try
381  {
382  const srdf::ModelSharedPtr& srdf =
383  rdf_loader_->getSRDF() ? rdf_loader_->getSRDF() : std::make_shared<srdf::Model>();
384  robot_model_ = std::make_shared<moveit::core::RobotModel>(rdf_loader_->getURDF(), srdf);
385  robot_->load(*robot_model_->getURDF());
386  robot_state_ = std::make_shared<moveit::core::RobotState>(robot_model_);
387  robot_state_->setToDefaultValues();
388  bool old_state = root_link_name_property_->blockSignals(true);
389  root_link_name_property_->setStdString(getRobotModel()->getRootLinkName());
390  root_link_name_property_->blockSignals(old_state);
391  update_state_ = true;
392  setStatus(rviz::StatusProperty::Ok, "RobotModel", "Loaded successfully");
393 
396  }
397  catch (std::exception& e)
398  {
399  setStatus(rviz::StatusProperty::Error, "RobotModel", QString("Loading failed: %1").arg(e.what()));
400  }
401  }
402  else
403  setStatus(rviz::StatusProperty::Error, "RobotModel", "Loading failed");
404 
405  highlights_.clear();
406 }
407 
408 void RobotStateDisplay::load(const rviz::Config& config)
409 {
410  // This property needs to be loaded in onEnable() below, which is triggered
411  // in the beginning of Display::load() before the other property would be available
412  robot_description_property_->load(config.mapGetChild("Robot Description"));
413  Display::load(config);
414 }
415 
417 {
418  Display::onEnable();
419  if (!rdf_loader_)
420  loadRobotModel();
423 }
424 
425 // ******************************************************************************************
426 // Disable
427 // ******************************************************************************************
429 {
431  if (robot_)
432  robot_->setVisible(false);
433  Display::onDisable();
434 }
435 
436 void RobotStateDisplay::update(float wall_dt, float ros_dt)
437 {
438  Display::update(wall_dt, ros_dt);
441  {
442  update_state_ = false;
443  robot_state_->update();
444  robot_->update(robot_state_);
445  }
446 }
447 
448 // ******************************************************************************************
449 // Calculate Offset Position
450 // ******************************************************************************************
452 {
453  if (!getRobotModel())
454  return;
455 
456  Ogre::Vector3 position;
457  Ogre::Quaternion orientation;
458 
459  context_->getFrameManager()->getTransform(getRobotModel()->getModelFrame(), ros::Time(0), position, orientation);
460 
461  scene_node_->setPosition(position);
462  scene_node_->setOrientation(orientation);
463 }
464 
466 {
467  Display::fixedFrameChanged();
469 }
470 
471 } // namespace moveit_rviz_plugin
rviz::BoolProperty::getBool
virtual bool getBool() const
rviz::Display::isEnabled
bool isEnabled() const
moveit_rviz_plugin::RobotStateDisplay::show_all_links_
rviz::BoolProperty * show_all_links_
Definition: robot_state_display.h:142
rviz::RosTopicProperty
rviz::ColorProperty::getColor
virtual QColor getColor() const
moveit_rviz_plugin::RobotStateDisplay::reset
void reset() override
Definition: robot_state_display.cpp:152
moveit_rviz_plugin::RobotStateDisplay::changedRobotSceneAlpha
void changedRobotSceneAlpha()
Definition: robot_state_display.cpp:305
moveit_rviz_plugin::RobotStateDisplay::calculateOffsetPosition
void calculateOffsetPosition()
Set the scene node's position, given the target frame and the planning frame.
Definition: robot_state_display.cpp:483
moveit_rviz_plugin::RobotStateDisplay::rdf_loader_
rdf_loader::RDFLoaderPtr rdf_loader_
Definition: robot_state_display.h:128
rviz::StatusProperty::Error
Error
moveit_rviz_plugin::RobotStateDisplay::highlights_
std::map< std::string, std_msgs::ColorRGBA > highlights_
Definition: robot_state_display.h:131
moveit_rviz_plugin::RobotStateDisplay::root_link_name_property_
rviz::StringProperty * root_link_name_property_
Definition: robot_state_display.h:135
moveit_rviz_plugin::RobotStateDisplay::root_nh_
ros::NodeHandle root_nh_
Definition: robot_state_display.h:124
moveit_rviz_plugin::RobotStateDisplay::changedEnableLinkHighlight
void changedEnableLinkHighlight()
Definition: robot_state_display.cpp:193
rviz::BoolProperty
moveit_rviz_plugin::RobotStateDisplay::update
void update(float wall_dt, float ros_dt) override
Definition: robot_state_display.cpp:468
frame_manager.h
srdf::ModelSharedPtr
std::shared_ptr< Model > ModelSharedPtr
moveit_rviz_plugin::RobotStateDisplay::changedRobotDescription
void changedRobotDescription()
Definition: robot_state_display.cpp:295
moveit_rviz_plugin::RobotStateDisplay::enable_link_highlight_
rviz::BoolProperty * enable_link_highlight_
Definition: robot_state_display.h:139
rviz::Property::subProp
virtual Property * subProp(const QString &sub_name)
ros::Subscriber::shutdown
void shutdown()
moveit_rviz_plugin::RobotStateDisplay::robot_alpha_property_
rviz::FloatProperty * robot_alpha_property_
Definition: robot_state_display.h:137
swap
void swap(Bag &a, Bag &b)
moveit_rviz_plugin::RobotStateDisplay::changedEnableVisualVisible
void changedEnableVisualVisible()
Definition: robot_state_display.cpp:211
moveit_rviz_plugin::RobotStateDisplay::setLinkColor
void setLinkColor(const std::string &link_name, const QColor &color)
Definition: robot_state_display.cpp:370
moveit_rviz_plugin::RobotStateDisplay::changedEnableCollisionVisible
void changedEnableCollisionVisible()
Definition: robot_state_display.cpp:216
float_property.h
rviz::ColorProperty
visualization_manager.h
moveit_rviz_plugin::RobotStateDisplay::enable_visual_visible_
rviz::BoolProperty * enable_visual_visible_
Definition: robot_state_display.h:140
rviz::FloatProperty
a
list a
moveit_rviz_plugin::RobotStateDisplay::changedAttachedBodyColor
void changedAttachedBodyColor()
Definition: robot_state_display.cpp:280
rviz::Display::setStatus
virtual void setStatus(StatusProperty::Level level, const QString &name, const QString &text)
message_checks.h
moveit::core::isEmpty
bool isEmpty(const geometry_msgs::Pose &msg)
bool_property.h
rviz::FloatProperty::getFloat
virtual float getFloat() const
rviz::Property::Property
Property(const QString &name, const QVariant &default_value, const QString &description, P *parent, Func &&changed_slot)
rviz::Display::scene_node_
Ogre::SceneNode * scene_node_
moveit_rviz_plugin::RobotStateDisplay::robot_state_topic_property_
rviz::RosTopicProperty * robot_state_topic_property_
Definition: robot_state_display.h:136
rviz::StringProperty
rviz::StringProperty::getStdString
std::string getStdString()
rviz::StatusProperty::Ok
Ok
moveit_rviz_plugin::RobotStateDisplay::robot_
RobotStateVisualizationPtr robot_
Definition: robot_state_display.h:127
rviz::StatusProperty::Warn
Warn
moveit_rviz_plugin::RobotStateDisplay::robot_description_property_
rviz::StringProperty * robot_description_property_
Definition: robot_state_display.h:134
moveit_rviz_plugin::RobotStateDisplay::onInitialize
void onInitialize() override
Definition: robot_state_display.cpp:143
moveit_rviz_plugin::operator!=
static bool operator!=(const std_msgs::ColorRGBA &a, const std_msgs::ColorRGBA &b)
Definition: robot_state_display.cpp:221
value
float value
moveit_rviz_plugin::RobotStateDisplay::onDisable
void onDisable() override
Definition: robot_state_display.cpp:460
moveit_rviz_plugin::RobotStateDisplay::~RobotStateDisplay
~RobotStateDisplay() override
ros::NodeHandle::subscribe
Subscriber subscribe(const std::string &topic, uint32_t queue_size, const boost::function< void(C)> &callback, const VoidConstPtr &tracked_object=VoidConstPtr(), const TransportHints &transport_hints=TransportHints())
rviz::DisplayContext::getFrameManager
virtual FrameManager * getFrameManager() const=0
rviz::Robot
moveit_rviz_plugin::RobotStateDisplay::unsetHighlight
void unsetHighlight(const std::string &link_name)
Definition: robot_state_display.cpp:183
moveit_rviz_plugin::RobotStateDisplay::getRobotModel
const moveit::core::RobotModelConstPtr & getRobotModel() const
Definition: robot_state_display.h:74
moveit_rviz_plugin
Definition: motion_planning_display.h:80
moveit_rviz_plugin::RobotStateDisplay::robot_model_
moveit::core::RobotModelConstPtr robot_model_
Definition: robot_state_display.h:129
rviz::FrameManager::getTransform
bool getTransform(const Header &header, Ogre::Vector3 &position, Ogre::Quaternion &orientation)
moveit_rviz_plugin::RobotStateDisplay::update_state_
bool update_state_
Definition: robot_state_display.h:132
moveit_rviz_plugin::RobotStateDisplay::attached_body_color_property_
rviz::ColorProperty * attached_body_color_property_
Definition: robot_state_display.h:138
moveit_rviz_plugin::RobotStateDisplay::load
void load(const rviz::Config &config) override
Definition: robot_state_display.cpp:440
moveit_rviz_plugin::RobotStateDisplay::setVisible
void setVisible(bool visible)
Definition: robot_state_display.cpp:380
rviz::Display::context_
DisplayContext * context_
moveit_rviz_plugin::RobotStateDisplay::unsetLinkColor
void unsetLinkColor(const std::string &link_name)
Definition: robot_state_display.cpp:375
ros::Time
moveit_rviz_plugin::RobotStateDisplay::changedRootLinkName
void changedRootLinkName()
Definition: robot_state_display.cpp:301
moveit_rviz_plugin::RobotStateDisplay::fixedFrameChanged
void fixedFrameChanged() override
Definition: robot_state_display.cpp:497
moveit_rviz_plugin::RobotStateDisplay::changedRobotStateTopic
void changedRobotStateTopic()
Definition: robot_state_display.cpp:321
property.h
rviz::StringProperty::setStdString
bool setStdString(const std::string &std_str)
srdf
robot_state_display.h
moveit_rviz_plugin::RobotStateDisplay::robot_state_
moveit::core::RobotStatePtr robot_state_
Definition: robot_state_display.h:130
conversions.h
moveit_rviz_plugin::RobotStateDisplay::setHighlight
void setHighlight(const std::string &link_name, const std_msgs::ColorRGBA &color)
Definition: robot_state_display.cpp:173
moveit_rviz_plugin::RobotStateDisplay::RobotStateDisplay
RobotStateDisplay()
Definition: robot_state_display.cpp:96
moveit_rviz_plugin::RobotStateDisplay::newRobotStateCallback
void newRobotStateCallback(const moveit_msgs::DisplayRobotState::ConstPtr &state)
Definition: robot_state_display.cpp:336
moveit_rviz_plugin::RobotStateDisplay::enable_collision_visible_
rviz::BoolProperty * enable_collision_visible_
Definition: robot_state_display.h:141
rviz::Robot::getLink
RobotLink * getLink(const std::string &name)
moveit::Exception
string_property.h
moveit_rviz_plugin::RobotStateDisplay::onEnable
void onEnable() override
Definition: robot_state_display.cpp:448
moveit_rviz_plugin::RobotStateDisplay::loadRobotModel
void loadRobotModel()
Definition: robot_state_display.cpp:406
moveit_rviz_plugin::RobotStateDisplay::setRobotHighlights
void setRobotHighlights(const moveit_msgs::DisplayRobotState::_highlight_links_type &highlight_links)
Definition: robot_state_display.cpp:226
config
config
rviz::Property::load
virtual void load(const Config &config)
rviz::Config
color_property.h
ros_topic_property.h
moveit_rviz_plugin::RobotStateDisplay::changedAllLinks
void changedAllLinks()
Definition: robot_state_display.cpp:161
moveit::core::robotStateMsgToRobotState
bool robotStateMsgToRobotState(const moveit_msgs::RobotState &robot_state, RobotState &state, bool copy_attached_bodies=true)
robot.h
display_context.h
moveit_rviz_plugin::RobotStateDisplay::robot_state_subscriber_
ros::Subscriber robot_state_subscriber_
Definition: robot_state_display.h:125


visualization
Author(s): Ioan Sucan , Dave Coleman , Sachin Chitta
autogenerated on Sat Mar 15 2025 02:27:26