visualization_manager.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2008, Willow Garage, Inc.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are met:
7  *
8  * * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  * * Redistributions in binary form must reproduce the above copyright
11  * notice, this list of conditions and the following disclaimer in the
12  * documentation and/or other materials provided with the distribution.
13  * * Neither the name of the Willow Garage, Inc. nor the names of its
14  * contributors may be used to endorse or promote products derived from
15  * this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
21  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27  * POSSIBILITY OF SUCH DAMAGE.
28  */
29 
30 #include <algorithm>
31 
32 #include <QApplication>
33 #include <QCursor>
34 #include <QPixmap>
35 #include <QTimer>
36 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
37 #include <QWindow>
38 #endif
39 
40 #include <boost/bind.hpp>
41 
42 #include <OgreRoot.h>
43 #include <OgreSceneManager.h>
44 #include <OgreSceneNode.h>
45 #include <OgreLight.h>
46 #include <OgreViewport.h>
47 #include <OgreMaterialManager.h>
48 #include <OgreMaterial.h>
49 #include <OgreRenderWindow.h>
50 #include <OgreSharedPtr.h>
51 #include <OgreCamera.h>
52 
53 #include <boost/filesystem.hpp>
54 
55 #include <tf/transform_listener.h>
56 
57 #include <ros/package.h>
58 #include <ros/callback_queue.h>
59 
60 #include "rviz/display.h"
61 #include "rviz/display_factory.h"
62 #include "rviz/display_group.h"
63 #include "rviz/displays_panel.h"
64 #include "rviz/frame_manager.h"
73 #include "rviz/render_panel.h"
75 #include "rviz/tool.h"
76 #include "rviz/tool_manager.h"
78 #include "rviz/view_controller.h"
79 #include "rviz/view_manager.h"
80 #include "rviz/load_resource.h"
83 
86 
87 namespace rviz
88 {
89 
90 //helper class needed to display an icon besides "Global Options"
91 class IconizedProperty: public Property {
92 public:
93  IconizedProperty( const QString& name = QString(),
94  const QVariant default_value = QVariant(),
95  const QString& description = QString(),
96  Property* parent = 0,
97  const char *changed_slot = 0,
98  QObject* receiver = 0 )
99  :Property( name, default_value, description, parent, changed_slot, receiver ) {};
100  virtual QVariant getViewData( int column, int role ) const
101  {
102  return (column == 0 && role == Qt::DecorationRole)
103  ? icon_ : Property::getViewData(column,role);
104  }
105  void setIcon( QIcon icon ) { icon_=icon; }
106 private:
107  QIcon icon_;
108 };
109 
111 {
112 public:
114  boost::thread_group threaded_queue_threads_;
117  boost::mutex render_mutex_;
118 };
119 
121 : ogre_root_( Ogre::Root::getSingletonPtr() )
122 , update_timer_(0)
123 , shutting_down_(false)
124 , render_panel_( render_panel )
125 , time_update_timer_(0.0f)
126 , frame_update_timer_(0.0f)
127 , render_requested_(1)
128 , frame_count_(0)
129 , window_manager_(wm)
130 , private_( new VisualizationManagerPrivate )
131 {
132  // visibility_bit_allocator_ is listed after default_visibility_bit_ (and thus initialized later be default):
134 
135  frame_manager_ = new FrameManager(tf);
136 
137  render_panel->setAutoRender(false);
138 
140 
141  scene_manager_ = ogre_root_->createSceneManager( Ogre::ST_GENERIC );
142 
143  rviz::RenderSystem::RenderSystem::get()->prepareOverlays(scene_manager_);
144 
145  directional_light_ = scene_manager_->createLight( "MainDirectional" );
146  directional_light_->setType( Ogre::Light::LT_DIRECTIONAL );
147  directional_light_->setDirection( Ogre::Vector3( -1, 0, -1 ) );
148  directional_light_->setDiffuseColour( Ogre::ColourValue( 1.0f, 1.0f, 1.0f ) );
149 
151  root_display_group_->setName( "root" );
154  connect( display_property_tree_model_, SIGNAL( configChanged() ), this, SIGNAL( configChanged() ));
155 
156  tool_manager_ = new ToolManager( this );
157  connect( tool_manager_, SIGNAL( configChanged() ), this, SIGNAL( configChanged() ));
158  connect( tool_manager_, SIGNAL( toolChanged( Tool* ) ), this, SLOT( onToolChanged( Tool* ) ));
159 
160  view_manager_ = new ViewManager( this );
162  connect( view_manager_, SIGNAL( configChanged() ), this, SIGNAL( configChanged() ));
163 
164  IconizedProperty* ip = new IconizedProperty( "Global Options", QVariant(), "", root_display_group_ );
165  ip->setIcon( loadPixmap("package://rviz/icons/options.png") );
166  global_options_ = ip;
167 
168  fixed_frame_property_ = new TfFrameProperty( "Fixed Frame", "/map",
169  "Frame into which all data is transformed before being displayed.",
171  SLOT( updateFixedFrame() ), this );
172 
173  background_color_property_ = new ColorProperty( "Background Color", QColor(48,48,48),
174  "Background color for the 3D view.",
175  global_options_, SLOT( updateBackgroundColor() ), this );
176 
177  fps_property_ = new IntProperty( "Frame Rate", 30,
178  "RViz will try to render this many frames per second.",
179  global_options_, SLOT( updateFps() ), this );
180 
181  default_light_enabled_property_ = new BoolProperty( "Default Light", true,
182  "Light source attached to the current 3D view.",
183  global_options_, SLOT( updateDefaultLightVisible() ), this );
184 
185  root_display_group_->initialize( this ); // only initialize() a Display after its sub-properties are created.
187 
190 
191  global_status_ = new StatusList( "Global Status", root_display_group_ );
192 
194 
196 
198 
200 
202  Ogre::Root::getSingletonPtr()->addFrameListener( ogre_render_queue_clearer_ );
203 
204  update_timer_ = new QTimer;
205  connect( update_timer_, SIGNAL( timeout() ), this, SLOT( onUpdate() ));
206 }
207 
209 {
210  delete update_timer_;
211 
212  shutting_down_ = true;
213  private_->threaded_queue_threads_.join_all();
214 
216  {
218  }
219 
221  delete tool_manager_;
222  delete display_factory_;
223  delete selection_manager_;
224 
225  if(ogre_root_)
226  {
227  ogre_root_->destroySceneManager( scene_manager_ );
228  }
229  delete frame_manager_;
230  delete private_;
231 
232  Ogre::Root::getSingletonPtr()->removeFrameListener( ogre_render_queue_clearer_ );
234 }
235 
237 {
238  emitStatusUpdate( "Initializing managers." );
239 
243 
246 }
247 
249 {
250  return &private_->threaded_queue_;
251 }
252 
254 {
255  private_->render_mutex_.lock();
256 }
257 
259 {
260  private_->render_mutex_.unlock();
261 }
262 
264 {
266 }
267 
269 {
270  float interval = 1000.0 / float(fps_property_->getInt());
271  update_timer_->start( interval );
272 }
273 
275 {
276  update_timer_->stop();
277 }
278 
279 void createColorMaterial(const std::string& name, const Ogre::ColourValue& color, bool use_self_illumination)
280 {
281  Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create( name, ROS_PACKAGE_NAME );
282  mat->setAmbient(color * 0.5f);
283  mat->setDiffuse(color);
284  if( use_self_illumination )
285  {
286  mat->setSelfIllumination(color);
287  }
288  mat->setLightingEnabled(true);
289  mat->setReceiveShadows(false);
290 }
291 
293 {
294  createColorMaterial("RVIZ/Red", Ogre::ColourValue(1.0f, 0.0f, 0.0f, 1.0f), true);
295  createColorMaterial("RVIZ/Green", Ogre::ColourValue(0.0f, 1.0f, 0.0f, 1.0f), true);
296  createColorMaterial("RVIZ/Blue", Ogre::ColourValue(0.0f, 0.0f, 1.0f, 1.0f), true);
297  createColorMaterial("RVIZ/Cyan", Ogre::ColourValue(0.0f, 1.0f, 1.0f, 1.0f), true);
298  createColorMaterial("RVIZ/ShadedRed", Ogre::ColourValue(1.0f, 0.0f, 0.0f, 1.0f), false);
299  createColorMaterial("RVIZ/ShadedGreen", Ogre::ColourValue(0.0f, 1.0f, 0.0f, 1.0f), false);
300  createColorMaterial("RVIZ/ShadedBlue", Ogre::ColourValue(0.0f, 0.0f, 1.0f, 1.0f), false);
301  createColorMaterial("RVIZ/ShadedCyan", Ogre::ColourValue(0.0f, 1.0f, 1.0f, 1.0f), false);
302 }
303 
305 {
306  render_requested_ = 1;
307 }
308 
310 {
313  float wall_dt = wall_diff.toSec();
314  float ros_dt = ros_diff.toSec();
317 
318  if(ros_dt < 0.0)
319  {
320  resetTime();
321  }
322 
323  ros::spinOnce();
324 
325  Q_EMIT preUpdate();
326 
328 
329  root_display_group_->update( wall_dt, ros_dt );
330 
331  view_manager_->update(wall_dt, ros_dt);
332 
333  time_update_timer_ += wall_dt;
334 
335  if( time_update_timer_ > 0.1f )
336  {
337  time_update_timer_ = 0.0f;
338 
339  updateTime();
340  }
341 
342  frame_update_timer_ += wall_dt;
343 
344  if(frame_update_timer_ > 1.0f)
345  {
346  frame_update_timer_ = 0.0f;
347 
348  updateFrames();
349  }
350 
352 
354  {
355  tool_manager_->getCurrentTool()->update(wall_dt, ros_dt);
356  }
357 
358  if ( view_manager_ &&
361  {
362  directional_light_->setDirection(view_manager_->getCurrent()->getCamera()->getDerivedDirection());
363  }
364 
365  frame_count_++;
366 
367  if ( render_requested_ || wall_dt > 0.01 )
368  {
369  render_requested_ = 0;
370  boost::mutex::scoped_lock lock(private_->render_mutex_);
371  ogre_root_->renderOneFrame();
372  }
373 }
374 
376 {
377  if( ros_time_begin_.isZero() )
378  {
380  }
381 
383 
384  if( wall_clock_begin_.isZero() )
385  {
387  }
388 
390 }
391 
393 {
394  typedef std::vector<std::string> V_string;
395  V_string frames;
397 
398  // Check the fixed frame to see if it's ok
399  std::string error;
400  if( frame_manager_->frameHasProblems( getFixedFrame().toStdString(), ros::Time(), error ))
401  {
402  if( frames.empty() )
403  {
404  // fixed_prop->setToWarn();
405  std::stringstream ss;
406  ss << "No tf data. Actual error: " << error;
407  global_status_->setStatus( StatusProperty::Warn, "Fixed Frame", QString::fromStdString( ss.str() ));
408  }
409  else
410  {
411  // fixed_prop->setToError();
412  global_status_->setStatus( StatusProperty::Error, "Fixed Frame", QString::fromStdString( error ));
413  }
414  }
415  else
416  {
417  // fixed_prop->setToOK();
418  global_status_->setStatus( StatusProperty::Ok, "Fixed Frame", "OK" );
419  }
420 }
421 
423 {
424  return frame_manager_->getTFClient();
425 }
426 
428 {
431 
434 
435  queueRender();
436 }
437 
438 void VisualizationManager::addDisplay( Display* display, bool enabled )
439 {
440  root_display_group_->addDisplay( display );
441  display->initialize( this );
442  display->setEnabled( enabled );
443 }
444 
446 {
448 }
449 
450 void VisualizationManager::emitStatusUpdate( const QString& message )
451 {
452  Q_EMIT statusUpdate( message );
453 }
454 
455 void VisualizationManager::load( const Config& config )
456 {
457  stopUpdate();
458 
459  emitStatusUpdate( "Creating displays" );
460  root_display_group_->load( config );
461 
462  emitStatusUpdate( "Creating tools" );
463  tool_manager_->load( config.mapGetChild( "Tools" ));
464 
465  emitStatusUpdate( "Creating views" );
466  view_manager_->load( config.mapGetChild( "Views" ));
467 
468  startUpdate();
469 }
470 
471 void VisualizationManager::save( Config config ) const
472 {
473  root_display_group_->save( config );
474  tool_manager_->save( config.mapMakeChild( "Tools" ));
475  view_manager_->save( config.mapMakeChild( "Views" ));
476 }
477 
478 Display* VisualizationManager::createDisplay( const QString& class_lookup_name,
479  const QString& name,
480  bool enabled )
481 {
482  QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
483  Display* new_display = root_display_group_->createDisplay( class_lookup_name );
484  addDisplay( new_display, enabled );
485  new_display->setName( name );
486  QApplication::restoreOverrideCursor();
487  return new_display;
488 }
489 
491 {
492  return ros::WallTime::now().toSec();
493 }
494 
496 {
497  return frame_manager_->getTime().toSec();
498 }
499 
501 {
502  return wall_clock_elapsed_.toSec();
503 }
504 
506 {
507  return (frame_manager_->getTime() - ros_time_begin_).toSec();
508 }
509 
511 {
513 
514  queueRender();
515 }
516 
518 {
519  if ( update_timer_->isActive() )
520  {
521  startUpdate();
522  }
523 }
524 
526 {
528 }
529 
531 {
532  //process pending mouse events
533  Tool* current_tool = tool_manager_->getCurrentTool();
534 
535  int flags = 0;
536  if( current_tool )
537  {
538  ViewportMouseEvent _vme = vme;
539 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
540  QWindow* window = vme.panel->windowHandle();
541  if (window)
542  {
543  double pixel_ratio = window->devicePixelRatio();
544  _vme.x = static_cast<int>(pixel_ratio * _vme.x);
545  _vme.y = static_cast<int>(pixel_ratio * _vme.y);
546  _vme.last_x = static_cast<int>(pixel_ratio * _vme.last_x);
547  _vme.last_y = static_cast<int>(pixel_ratio * _vme.last_y);
548  }
549 #endif
550  flags = current_tool->processMouseEvent( _vme );
551  vme.panel->setCursor( current_tool->getCursor() );
552  }
553  else
554  {
555  vme.panel->setCursor( QCursor( Qt::ArrowCursor ) );
556  }
557 
558  if( flags & Tool::Render )
559  {
560  queueRender();
561  }
562 
563  if( flags & Tool::Finished )
564  {
566  }
567 }
568 
569 void VisualizationManager::handleChar( QKeyEvent* event, RenderPanel* panel )
570 {
571  tool_manager_->handleChar( event, panel );
572 }
573 
575 {
576  while (!shutting_down_)
577  {
579  }
580 }
581 
583 {
584  Q_EMIT configChanged();
585 }
586 
588 {
589 }
590 
592 {
593  QString frame = fixed_frame_property_->getFrame();
594 
595  frame_manager_->setFixedFrame( frame.toStdString() );
597 }
598 
600 {
602 }
603 
604 void VisualizationManager::setFixedFrame( const QString& frame )
605 {
607 }
608 
609 void VisualizationManager::setStatus( const QString & message )
610 {
611  emitStatusUpdate( message );
612 }
613 
614 } // namespace rviz
virtual void save(Config config) const
Save subproperties and the list of displays in this group to the given Config node.
virtual QColor getColor() const
void initialize()
Do initialization that wasn&#39;t done in constructor. Initializes tool manager, view manager...
void getFrameStrings(std::vector< std::string > &ids) const
OgreRenderQueueClearer * ogre_render_queue_clearer_
void load(const Config &config)
ViewController * getCurrent() const
Return the current ViewController in use for the main RenderWindow.
virtual int processMouseEvent(ViewportMouseEvent &event)
Definition: tool.h:97
VisualizationManager(RenderPanel *render_panel, WindowManagerInterface *wm=0, boost::shared_ptr< tf::TransformListener > tf=boost::shared_ptr< tf::TransformListener >())
Constructor Creates managers and sets up global properties.
f
boost::unordered_map< CollObjectHandle, Picked > M_Picked
Definition: forwards.h:65
VisualizationManagerPrivate * private_
void update()
Clear the internal cache.
void onUpdate()
Call update() on all managed objects.
void configChanged()
Emitted whenever the display configuration changes.
void setAutoRender(bool auto_render)
virtual int getInt() const
Return the internal property value as an integer.
Definition: int_property.h:73
Display * createDisplay(const QString &class_lookup_name, const QString &name, bool enabled)
Create and add a display to this panel, by class lookup name.
TfFrameProperty * fixed_frame_property_
Frame to transform fixed data to.
IconizedProperty(const QString &name=QString(), const QVariant default_value=QVariant(), const QString &description=QString(), Property *parent=0, const char *changed_slot=0, QObject *receiver=0)
void setSelection(const M_Picked &objs)
A single element of a property tree, with a name, value, description, and possibly children...
Definition: property.h:100
virtual QVariant getViewData(int column, int role) const
Return data appropriate for the given column (0 or 1) and role for this Property. ...
virtual void load(const Config &config)
Load subproperties and the list of displays in this group from the given Config node, which must be a map.
void preUpdate()
Emitted before updating all Displays.
virtual bool setValue(const QVariant &new_value)
Override from Property to resolve the frame name on the way in.
void setFixedFrame(const QString &frame)
Set the coordinate frame we should be transforming all fixed data into.
virtual QVariant getViewData(int column, int role) const
Return data appropriate for the given column (0 or 1) and role for this Property. ...
Definition: property.cpp:236
CallOneResult callOne()
void unlockRender()
Unlock a mutex, allowing calls to Ogre::Root::renderOneFrame().
BoolProperty * default_light_enabled_property_
Tool * getCurrentTool()
Return the tool currently in use.
Definition: tool_manager.h:69
ros::Time getTime()
Get current time, depending on the sync mode.
void lockRender()
Lock a mutex to delay calls to Ogre::Root::renderOneFrame().
ros::CallbackQueueInterface * getUpdateQueue()
Return the CallbackQueue using the main GUI thread.
Property specialized to provide max/min enforcement for integers.
Definition: int_property.h:38
tf::TransformListener * getTFClient() const
Convenience function: returns getFrameManager()->getTFClient().
void emitStatusUpdate(const QString &message)
Emits statusUpdate() signal with the given message.
const QCursor & getCursor()
Get current cursor of this tool.
Definition: tool.h:160
Display * createDisplay(const QString &class_id)
void initialize()
Initialization for after the DisplayContext is created. Loads standard RViz tools.
void handleMouseEvent(const ViewportMouseEvent &event)
Handle a mouse event.
void setCurrentTool(Tool *tool)
Set the current tool. The current tool is given all mouse and keyboard events which VisualizationMana...
Configuration data storage class.
Definition: config.h:125
ros::CallbackQueueInterface * getThreadedQueue()
Return a CallbackQueue using a different thread than the main GUI one.
Ogre::ColourValue qtToOgre(const QColor &c)
Definition: parse_color.cpp:87
virtual bool getBool() const
ROSCPP_DECL CallbackQueue * getGlobalCallbackQueue()
void createColorMaterial(const std::string &name, const Ogre::ColourValue &color, bool use_self_illumination)
double getWallClock()
Return the wall clock time, in seconds since 1970.
QTimer * update_timer_
Update timer. Display::update is called on each display whenever this timer fires.
description
Helper class for transforming data into Ogre&#39;s world frame (the fixed frame).
Definition: frame_manager.h:63
double getROSTimeElapsed()
Return the ROS time in seconds since the last reset.
void addDisplay(Display *display, bool enabled)
Add a display to be managed by this panel.
A Display object which stores other Displays as children.
Definition: display_group.h:47
void handleChar(QKeyEvent *event, RenderPanel *panel)
Handle a single key event for a given RenderPanel.
void statusUpdate(const QString &message)
Emitted during file-loading and initialization to indicate progress.
void setCallbackQueue(CallbackQueueInterface *queue)
def default_value(type)
Ogre::Camera * getCamera() const
void setRenderPanel(RenderPanel *render_panel)
Set the 3D view widget whose view will be controlled by ViewController instances from by this ViewMan...
Config mapMakeChild(const QString &key)
Create a child node stored with the given key, and return the child.
Definition: config.cpp:190
void queueRender()
Queues a render. Multiple calls before a render happens will only cause a single render.
virtual void removeAllDisplays()
Remove and destroy all child Displays, but preserve any non-Display children.
ros::Time last_update_ros_time_
Update stopwatch. Stores how long it&#39;s been since the last update.
double getROSTime()
Return the ROS time, in seconds.
tf::TransformListener * getTFClient()
Return the tf::TransformListener used to receive transform data.
virtual void reset()
Reset this and all child Displays.
virtual void update(float wall_dt, float ros_dt)
Call update() on all child Displays.
void update(float wall_dt, float ros_dt)
void setBackgroundColor(Ogre::ColourValue color)
void load(const Config &config)
Load the properties of each Display and most editable rviz data.
void setFixedFrame(const QString &fixed_frame)
Set the fixed frame in this display.
Definition: display.cpp:286
std::vector< std::string > V_string
void save(Config config) const
Save the properties of each Display and most editable rviz data.
void handleChar(QKeyEvent *event, RenderPanel *panel)
void save(Config config) const
Ogre::Root * ogre_root_
Ogre Root.
void setDragDropClass(const QString &drag_drop_class)
virtual void setStatus(const QString &message)
void setFixedFrame(const std::string &frame)
Set the frame to consider "fixed", into which incoming data is transformed.
void setEnabled(bool enabled)
Enable or disable this Display.
Definition: display.cpp:270
void setStatus(Level level, const QString &name, const QString &text)
Definition: status_list.cpp:52
void setName(const QString &name)
Overridden from Property to set associated widget title to the new name.
Definition: display.cpp:410
static WallTime now()
Property specialized to provide getter for booleans.
Definition: bool_property.h:38
double getWallClockElapsed()
Return the wall clock time in seconds since the last reset.
void removeAllDisplays()
Remove and delete all displays.
bool frameHasProblems(const std::string &frame, ros::Time time, std::string &error)
Check to see if a frame exists in the tf::TransformListener.
virtual ~VisualizationManager()
Destructor Stops update timers and destroys all displays, tools, and managers.
static Time now()
void notifyConfigChanged()
Notify this VisualizationManager that something about its display configuration has changed...
ColorProperty * background_color_property_
void initialize(DisplayContext *context)
Main initialization, called after constructor, before load() or setEnabled().
Definition: display.cpp:84
PropertyTreeModel * display_property_tree_model_
Config mapGetChild(const QString &key) const
If the referenced Node is a Map and it has a child with the given key, return a reference to the chil...
Definition: config.cpp:201
void save(Config config) const
virtual void update(float wall_dt, float ros_dt)
Definition: tool.h:84
ROSCPP_DECL void spinOnce()
virtual void addDisplay(Display *child)
Add a child Display to the end of the list of Displays.
Tool * getDefaultTool()
Get the default tool.
Definition: tool_manager.h:112
Ogre::SceneManager * scene_manager_
Ogre scene manager associated with this panel.
void startUpdate()
Start timers. Creates and starts the update and idle timers, both set to 30Hz (33ms).
QPixmap loadPixmap(QString url, bool fill_cache)
void resetTime()
Resets the wall and ROS elapsed time to zero and calls resetDisplays().
QString getFixedFrame() const
Return the fixed frame name.
SelectionManager * selection_manager_
void load(const Config &config)
uint32_t allocBit()
Return a uint32 with a single bit "on" (previously unused), or a 0 if all bits are already allocated...


rviz
Author(s): Dave Hershberger, David Gossow, Josh Faust
autogenerated on Sat Apr 27 2019 02:33:42