Point Cloud Library (PCL)  1.14.0-dev
pcl_visualizer.h
1 /*
2  * Software License Agreement (BSD License)
3  *
4  * Point Cloud Library (PCL) - www.pointclouds.org
5  * Copyright (c) 2010-2011, Willow Garage, Inc.
6  * Copyright (c) 2012-, Open Perception, Inc.
7  *
8  * All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  *
14  * * Redistributions of source code must retain the above copyright
15  * notice, this list of conditions and the following disclaimer.
16  * * Redistributions in binary form must reproduce the above
17  * copyright notice, this list of conditions and the following
18  * disclaimer in the documentation and/or other materials provided
19  * with the distribution.
20  * * Neither the name of the copyright holder(s) nor the names of its
21  * contributors may be used to endorse or promote products derived
22  * from this software without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
27  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
28  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
29  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
30  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
31  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
32  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
34  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35  * POSSIBILITY OF SUCH DAMAGE.
36  *
37  */
38 
39 #pragma once
40 
41 // PCL includes
42 #include <pcl/correspondence.h>
43 #include <pcl/ModelCoefficients.h>
44 #include <pcl/PolygonMesh.h>
45 #include <pcl/TextureMesh.h>
46 //
47 #include <pcl/console/print.h>
48 #include <pcl/visualization/common/actor_map.h>
49 #include <pcl/visualization/common/common.h>
50 #include <pcl/visualization/point_cloud_geometry_handlers.h>
51 #include <pcl/visualization/point_cloud_color_handlers.h>
52 #include <pcl/visualization/point_picking_event.h>
53 #include <pcl/visualization/area_picking_event.h>
54 #include <pcl/visualization/interactor_style.h>
55 
56 #include <vtkOrientationMarkerWidget.h>
57 #include <vtkRenderWindowInteractor.h>
58 
59 // VTK includes
60 class vtkPolyData;
61 class vtkTextActor;
62 class vtkRenderWindow;
63 class vtkAppendPolyData;
64 class vtkRenderWindow;
65 class vtkTransform;
66 class vtkInteractorStyle;
67 class vtkLODActor;
68 class vtkProp;
69 class vtkActor;
70 class vtkDataSet;
71 class vtkUnstructuredGrid;
72 class vtkCellArray;
73 
74 namespace pcl
75 {
76  template <typename T> class PointCloud;
77  template <typename T> class PlanarPolygon;
78 
79  namespace visualization
80  {
81  namespace details
82  {
83  PCL_EXPORTS vtkIdType fillCells(std::vector<int>& lookup, const std::vector<pcl::Vertices>& vertices, vtkSmartPointer<vtkCellArray> cell_array, int max_size_of_polygon);
84  }
85 
86  /** \brief PCL Visualizer main class.
87  * \author Radu B. Rusu
88  * \ingroup visualization
89  * \note This class can NOT be used across multiple threads. Only call functions of objects of this class
90  * from the same thread that they were created in! Some methods, e.g. addPointCloud, will crash if called
91  * from other threads.
92  */
93  class PCL_EXPORTS PCLVisualizer
94  {
95  public:
96  using Ptr = shared_ptr<PCLVisualizer>;
97  using ConstPtr = shared_ptr<const PCLVisualizer>;
98 
99  using GeometryHandler = PointCloudGeometryHandler<pcl::PCLPointCloud2>;
100  using GeometryHandlerPtr = GeometryHandler::Ptr;
101  using GeometryHandlerConstPtr = GeometryHandler::ConstPtr;
102 
103  using ColorHandler = PointCloudColorHandler<pcl::PCLPointCloud2>;
104  using ColorHandlerPtr = ColorHandler::Ptr;
105  using ColorHandlerConstPtr = ColorHandler::ConstPtr;
106 
107  /** \brief PCL Visualizer constructor.
108  * \param[in] name the window name (empty by default)
109  * \param[in] create_interactor if true (default), create an interactor, false otherwise
110  */
111  PCLVisualizer (const std::string &name = "", const bool create_interactor = true);
112 
113  /** \brief PCL Visualizer constructor. It looks through the passed argv arguments to find the "-cam *.cam" argument.
114  * If the search failed, the name for cam file is calculated with boost uuid. If there is no such file, camera is not initialized.
115  * \param[in] argc
116  * \param[in] argv
117  * \param[in] name the window name (empty by default)
118  * \param[in] style interactor style (defaults to PCLVisualizerInteractorStyle)
119  * \param[in] create_interactor if true (default), create an interactor, false otherwise
120  */
121  PCLVisualizer (int &argc, char **argv, const std::string &name = "",
122  PCLVisualizerInteractorStyle* style = PCLVisualizerInteractorStyle::New (), const bool create_interactor = true);
123 
124  /** \brief PCL Visualizer constructor.
125  * \param[in] ren custom vtk renderer
126  * \param[in] wind custom vtk render window
127  * \param[in] create_interactor if true (default), create an interactor, false otherwise
128  */
129  PCLVisualizer (vtkSmartPointer<vtkRenderer> ren, vtkSmartPointer<vtkRenderWindow> wind, const std::string &name = "", const bool create_interactor = true);
130 
131  /** \brief PCL Visualizer constructor.
132  * \param[in] argc
133  * \param[in] argv
134  * \param[in] ren custom vtk renderer
135  * \param[in] wind custom vtk render window
136  * \param[in] style interactor style (defaults to PCLVisualizerInteractorStyle)
137  * \param[in] create_interactor if true (default), create an interactor, false otherwise
138  */
139  PCLVisualizer (int &argc, char **argv, vtkSmartPointer<vtkRenderer> ren, vtkSmartPointer<vtkRenderWindow> wind, const std::string &name = "",
140  PCLVisualizerInteractorStyle* style = PCLVisualizerInteractorStyle::New (),
141  const bool create_interactor = true);
142 
143 
144  /** \brief PCL Visualizer destructor. */
145  virtual ~PCLVisualizer ();
146 
147  /** \brief Enables/Disabled the underlying window mode to full screen.
148  * \note This might or might not work, depending on your window manager.
149  * See the VTK documentation for additional details.
150  * \param[in] mode true for full screen, false otherwise
151  */
152  void
153  setFullScreen (bool mode);
154 
155  /** \brief Set the visualizer window name.
156  * \param[in] name the name of the window
157  */
158  void
159  setWindowName (const std::string &name);
160 
161  /** \brief Enables or disable the underlying window borders.
162  * \note This might or might not work, depending on your window manager.
163  * See the VTK documentation for additional details.
164  * \param[in] mode true for borders, false otherwise
165  */
166  void
167  setWindowBorders (bool mode);
168 
169  /** \brief Register a callback std::function for keyboard events
170  * \param[in] cb a std function that will be registered as a callback for a keyboard event
171  * \return a connection object that allows to disconnect the callback function.
172  */
173  boost::signals2::connection
174  registerKeyboardCallback (std::function<void (const pcl::visualization::KeyboardEvent&)> cb);
175 
176  /** \brief Register a callback function for keyboard events
177  * \param[in] callback the function that will be registered as a callback for a keyboard event
178  * \param[in] cookie user data that is passed to the callback
179  * \return a connection object that allows to disconnect the callback function.
180  */
181  inline boost::signals2::connection
182  registerKeyboardCallback (void (*callback) (const pcl::visualization::KeyboardEvent&, void*), void* cookie = nullptr)
183  {
184  return (registerKeyboardCallback ([=] (const pcl::visualization::KeyboardEvent& e) { (*callback) (e, cookie); }));
185  }
186 
187  /** \brief Register a callback function for keyboard events
188  * \param[in] callback the member function that will be registered as a callback for a keyboard event
189  * \param[in] instance instance to the class that implements the callback function
190  * \param[in] cookie user data that is passed to the callback
191  * \return a connection object that allows to disconnect the callback function.
192  */
193  template<typename T> inline boost::signals2::connection
194  registerKeyboardCallback (void (T::*callback) (const pcl::visualization::KeyboardEvent&, void*), T& instance, void* cookie = nullptr)
195  {
196  return (registerKeyboardCallback ([=, &instance] (const pcl::visualization::KeyboardEvent& e) { (instance.*callback) (e, cookie); }));
197  }
198 
199  /** \brief Register a callback function for mouse events
200  * \param[in] cb a std function that will be registered as a callback for a mouse event
201  * \return a connection object that allows to disconnect the callback function.
202  */
203  boost::signals2::connection
204  registerMouseCallback (std::function<void (const pcl::visualization::MouseEvent&)> cb);
205 
206  /** \brief Register a callback function for mouse events
207  * \param[in] callback the function that will be registered as a callback for a mouse event
208  * \param[in] cookie user data that is passed to the callback
209  * \return a connection object that allows to disconnect the callback function.
210  */
211  inline boost::signals2::connection
212  registerMouseCallback (void (*callback) (const pcl::visualization::MouseEvent&, void*), void* cookie = nullptr)
213  {
214  return (registerMouseCallback ([=] (const pcl::visualization::MouseEvent& e) { (*callback) (e, cookie); }));
215  }
216 
217  /** \brief Register a callback function for mouse events
218  * \param[in] callback the member function that will be registered as a callback for a mouse event
219  * \param[in] instance instance to the class that implements the callback function
220  * \param[in] cookie user data that is passed to the callback
221  * \return a connection object that allows to disconnect the callback function.
222  */
223  template<typename T> inline boost::signals2::connection
224  registerMouseCallback (void (T::*callback) (const pcl::visualization::MouseEvent&, void*), T& instance, void* cookie = nullptr)
225  {
226  return (registerMouseCallback ([=, &instance] (const pcl::visualization::MouseEvent& e) { (instance.*callback) (e, cookie); }));
227  }
228 
229  /** \brief Register a callback function for point picking events
230  * \param[in] cb a std function that will be registered as a callback for a point picking event
231  * \return a connection object that allows to disconnect the callback function.
232  */
233  boost::signals2::connection
234  registerPointPickingCallback (std::function<void (const pcl::visualization::PointPickingEvent&)> cb);
235 
236  /** \brief Register a callback function for point picking events
237  * \param[in] callback the function that will be registered as a callback for a point picking event
238  * \param[in] cookie user data that is passed to the callback
239  * \return a connection object that allows to disconnect the callback function.
240  */
241  boost::signals2::connection
242  registerPointPickingCallback (void (*callback) (const pcl::visualization::PointPickingEvent&, void*), void* cookie = nullptr);
243 
244  /** \brief Register a callback function for point picking events
245  * \param[in] callback the member function that will be registered as a callback for a point picking event
246  * \param[in] instance instance to the class that implements the callback function
247  * \param[in] cookie user data that is passed to the callback
248  * \return a connection object that allows to disconnect the callback function.
249  */
250  template<typename T> inline boost::signals2::connection
251  registerPointPickingCallback (void (T::*callback) (const pcl::visualization::PointPickingEvent&, void*), T& instance, void* cookie = nullptr)
252  {
253  return (registerPointPickingCallback ([=, &instance] (const pcl::visualization::PointPickingEvent& e) { (instance.*callback) (e, cookie); }));
254  }
255 
256  /** \brief Register a callback function for area picking events
257  * \param[in] cb a std function that will be registered as a callback for an area picking event
258  * \return a connection object that allows to disconnect the callback function.
259  */
260  boost::signals2::connection
261  registerAreaPickingCallback (std::function<void (const pcl::visualization::AreaPickingEvent&)> cb);
262 
263  /** \brief Register a callback function for area picking events
264  * \param[in] callback the function that will be registered as a callback for an area picking event
265  * \param[in] cookie user data that is passed to the callback
266  * \return a connection object that allows to disconnect the callback function.
267  */
268  boost::signals2::connection
269  registerAreaPickingCallback (void (*callback) (const pcl::visualization::AreaPickingEvent&, void*), void* cookie = nullptr);
270 
271  /** \brief Register a callback function for area picking events
272  * \param[in] callback the member function that will be registered as a callback for an area picking event
273  * \param[in] instance instance to the class that implements the callback function
274  * \param[in] cookie user data that is passed to the callback
275  * \return a connection object that allows to disconnect the callback function.
276  */
277  template<typename T> inline boost::signals2::connection
278  registerAreaPickingCallback (void (T::*callback) (const pcl::visualization::AreaPickingEvent&, void*), T& instance, void* cookie = nullptr)
279  {
280  return (registerAreaPickingCallback ([=, &instance] (const pcl::visualization::AreaPickingEvent& e) { (instance.*callback) (e, cookie); }));
281  }
282 
283  /** \brief Spin method. Calls the interactor and runs an internal loop. */
284  void
285  spin ();
286 
287  /** \brief Spin once method. Calls the interactor and updates the screen once.
288  * \param[in] time - How long (in ms) should the visualization loop be allowed to run.
289  * \param[in] force_redraw - if false it might return without doing anything if the
290  * interactor's framerate does not require a redraw yet.
291  * \note This function may not return immediately after the specified time has elapsed, for example if
292  * the user continues to interact with the visualizer, meaning that there are still events to process.
293  */
294  void
295  spinOnce (int time = 1, bool force_redraw = false);
296 
297  /** \brief Adds a widget which shows an interactive axes display for orientation
298  * \param[in] interactor - Pointer to the vtk interactor object used by the PCLVisualizer window
299  */
300  void
301  addOrientationMarkerWidgetAxes (vtkRenderWindowInteractor* interactor);
302 
303  /** \brief Disables the Orientatation Marker Widget so it is removed from the renderer */
304  void
305  removeOrientationMarkerWidgetAxes ();
306 
307  /** \brief Adds 3D axes describing a coordinate system to screen at 0,0,0.
308  * \param[in] scale the scale of the axes (default: 1)
309  * \param[in] id the coordinate system object id (default: reference)
310  * \param[in] viewport the view port where the 3D axes should be added (default: all)
311  */
312  void
313  addCoordinateSystem (double scale = 1.0, const std::string& id = "reference", int viewport = 0);
314 
315  /** \brief Adds 3D axes describing a coordinate system to screen at x, y, z
316  * \param[in] scale the scale of the axes (default: 1)
317  * \param[in] x the X position of the axes
318  * \param[in] y the Y position of the axes
319  * \param[in] z the Z position of the axes
320  * \param[in] id the coordinate system object id (default: reference)
321  * \param[in] viewport the view port where the 3D axes should be added (default: all)
322  */
323  void
324  addCoordinateSystem (double scale, float x, float y, float z, const std::string &id = "reference", int viewport = 0);
325 
326  /** \brief Adds 3D axes describing a coordinate system to screen at x, y, z, Roll,Pitch,Yaw
327  *
328  * \param[in] scale the scale of the axes (default: 1)
329  * \param[in] t transformation matrix
330  * \param[in] id the coordinate system object id (default: reference)
331  * \param[in] viewport the view port where the 3D axes should be added (default: all)
332  *
333  * RPY Angles
334  * Rotate the reference frame by the angle roll about axis x
335  * Rotate the reference frame by the angle pitch about axis y
336  * Rotate the reference frame by the angle yaw about axis z
337  *
338  * Description:
339  * Sets the orientation of the Prop3D. Orientation is specified as
340  * X,Y and Z rotations in that order, but they are performed as
341  * RotateZ, RotateX, and finally RotateY.
342  *
343  * All axies use right hand rule. x=red axis, y=green axis, z=blue axis
344  * z direction is point into the screen.
345  * \code
346  * z
347  * \
348  * \
349  * \
350  * -----------> x
351  * |
352  * |
353  * |
354  * |
355  * |
356  * |
357  * y
358  * \endcode
359  */
360 
361  void
362  addCoordinateSystem (double scale, const Eigen::Affine3f& t, const std::string &id = "reference", int viewport = 0);
363 
364  /** \brief Removes a previously added 3D axes (coordinate system)
365  * \param[in] id the coordinate system object id (default: reference)
366  * \param[in] viewport view port where the 3D axes should be removed from (default: all)
367  */
368  bool
369  removeCoordinateSystem (const std::string &id = "reference", int viewport = 0);
370 
371  /** \brief Removes a Point Cloud from screen, based on a given ID.
372  * \param[in] id the point cloud object id (i.e., given on \a addPointCloud)
373  * \param[in] viewport view port from where the Point Cloud should be removed (default: all)
374  * \return true if the point cloud is successfully removed and false if the point cloud is
375  * not actually displayed
376  */
377  bool
378  removePointCloud (const std::string &id = "cloud", int viewport = 0);
379 
380  /** \brief Removes a PolygonMesh from screen, based on a given ID.
381  * \param[in] id the polygon object id (i.e., given on \a addPolygonMesh)
382  * \param[in] viewport view port from where the PolygonMesh should be removed (default: all)
383  */
384  inline bool
385  removePolygonMesh (const std::string &id = "polygon", int viewport = 0)
386  {
387  // Polygon Meshes are represented internally as point clouds with special cell array structures since 1.4
388  return (removePointCloud (id, viewport));
389  }
390 
391  /** \brief Removes an added shape from screen (line, polygon, etc.), based on a given ID
392  * \note This methods also removes PolygonMesh objects and PointClouds, if they match the ID
393  * \param[in] id the shape object id (i.e., given on \a addLine etc.)
394  * \param[in] viewport view port from where the Point Cloud should be removed (default: all)
395  */
396  bool
397  removeShape (const std::string &id = "cloud", int viewport = 0);
398 
399  /** \brief Removes an added 3D text from the scene, based on a given ID
400  * \param[in] id the 3D text id (i.e., given on \a addText3D etc.)
401  * \param[in] viewport view port from where the 3D text should be removed (default: all)
402  */
403  bool
404  removeText3D (const std::string &id = "cloud", int viewport = 0);
405 
406  /** \brief Remove all point cloud data on screen from the given viewport.
407  * \param[in] viewport view port from where the clouds should be removed (default: all)
408  */
409  bool
410  removeAllPointClouds (int viewport = 0);
411 
412  /** \brief Remove all 3D shape data on screen from the given viewport.
413  * \param[in] viewport view port from where the shapes should be removed (default: all)
414  */
415  bool
416  removeAllShapes (int viewport = 0);
417 
418  /** \brief Removes all existing 3D axes (coordinate systems)
419  * \param[in] viewport view port where the 3D axes should be removed from (default: all)
420  */
421  bool
422  removeAllCoordinateSystems (int viewport = 0);
423 
424  /** \brief Set the viewport's background color.
425  * \param[in] r the red component of the RGB color
426  * \param[in] g the green component of the RGB color
427  * \param[in] b the blue component of the RGB color
428  * \param[in] viewport the view port (default: all)
429  */
430  void
431  setBackgroundColor (const double &r, const double &g, const double &b, int viewport = 0);
432 
433  /** \brief Add a text to screen
434  * \param[in] text the text to add
435  * \param[in] xpos the X position on screen where the text should be added
436  * \param[in] ypos the Y position on screen where the text should be added
437  * \param[in] id the text object id (default: equal to the "text" parameter)
438  * \param[in] viewport the view port (default: all)
439  */
440  bool
441  addText (const std::string &text,
442  int xpos, int ypos,
443  const std::string &id = "", int viewport = 0);
444 
445  /** \brief Add a text to screen
446  * \param[in] text the text to add
447  * \param[in] xpos the X position on screen where the text should be added
448  * \param[in] ypos the Y position on screen where the text should be added
449  * \param[in] r the red color value
450  * \param[in] g the green color value
451  * \param[in] b the blue color value
452  * \param[in] id the text object id (default: equal to the "text" parameter)
453  * \param[in] viewport the view port (default: all)
454  */
455  bool
456  addText (const std::string &text, int xpos, int ypos, double r, double g, double b,
457  const std::string &id = "", int viewport = 0);
458 
459  /** \brief Add a text to screen
460  * \param[in] text the text to add
461  * \param[in] xpos the X position on screen where the text should be added
462  * \param[in] ypos the Y position on screen where the text should be added
463  * \param[in] fontsize the fontsize of the text
464  * \param[in] r the red color value
465  * \param[in] g the green color value
466  * \param[in] b the blue color value
467  * \param[in] id the text object id (default: equal to the "text" parameter)
468  * \param[in] viewport the view port (default: all)
469  */
470  bool
471  addText (const std::string &text, int xpos, int ypos, int fontsize, double r, double g, double b,
472  const std::string &id = "", int viewport = 0);
473 
474 
475  /** \brief Update a text to screen
476  * \param[in] text the text to update
477  * \param[in] xpos the new X position on screen
478  * \param[in] ypos the new Y position on screen
479  * \param[in] id the text object id (default: equal to the "text" parameter)
480  */
481  bool
482  updateText (const std::string &text,
483  int xpos, int ypos,
484  const std::string &id = "");
485 
486  /** \brief Update a text to screen
487  * \param[in] text the text to update
488  * \param[in] xpos the new X position on screen
489  * \param[in] ypos the new Y position on screen
490  * \param[in] r the red color value
491  * \param[in] g the green color value
492  * \param[in] b the blue color value
493  * \param[in] id the text object id (default: equal to the "text" parameter)
494  */
495  bool
496  updateText (const std::string &text,
497  int xpos, int ypos, double r, double g, double b,
498  const std::string &id = "");
499 
500  /** \brief Update a text to screen
501  * \param[in] text the text to update
502  * \param[in] xpos the new X position on screen
503  * \param[in] ypos the new Y position on screen
504  * \param[in] fontsize the fontsize of the text
505  * \param[in] r the red color value
506  * \param[in] g the green color value
507  * \param[in] b the blue color value
508  * \param[in] id the text object id (default: equal to the "text" parameter)
509  */
510  bool
511  updateText (const std::string &text,
512  int xpos, int ypos, int fontsize, double r, double g, double b,
513  const std::string &id = "");
514 
515  /** \brief Set the pose of an existing shape.
516  *
517  * Returns false if the shape doesn't exist, true if the pose was successfully
518  * updated.
519  *
520  * \param[in] id the shape or cloud object id (i.e., given on \a addLine etc.)
521  * \param[in] pose the new pose
522  * \return false if no shape or cloud with the specified ID was found
523  */
524  bool
525  updateShapePose (const std::string &id, const Eigen::Affine3f& pose);
526 
527  /** \brief Set the pose of an existing coordinate system.
528  *
529  * Returns false if the coordinate system doesn't exist, true if the pose was successfully
530  * updated.
531  *
532  * \param[in] id the point cloud object id (i.e., given on \a addCoordinateSystem etc.)
533  * \param[in] pose the new pose
534  * \return false if no coordinate system with the specified ID was found
535  */
536  bool
537  updateCoordinateSystemPose (const std::string &id, const Eigen::Affine3f& pose);
538 
539  /** \brief Set the pose of an existing point cloud.
540  *
541  * Returns false if the point cloud doesn't exist, true if the pose was successfully
542  * updated.
543  *
544  * \param[in] id the point cloud object id (i.e., given on \a addPointCloud etc.)
545  * \param[in] pose the new pose
546  * \return false if no point cloud with the specified ID was found
547  */
548  bool
549  updatePointCloudPose (const std::string &id, const Eigen::Affine3f& pose);
550 
551  /** \brief Add a 3d text to the scene
552  * \param[in] text the text to add
553  * \param[in] position the world position where the text should be added
554  * \param[in] textScale the scale of the text to render
555  * \param[in] r the red color value
556  * \param[in] g the green color value
557  * \param[in] b the blue color value
558  * \param[in] id the text object id (default: equal to the "text" parameter)
559  * \param[in] viewport the view port (default: all)
560  */
561  template <typename PointT> bool
562  addText3D (const std::string &text,
563  const PointT &position,
564  double textScale = 1.0,
565  double r = 1.0, double g = 1.0, double b = 1.0,
566  const std::string &id = "", int viewport = 0);
567 
568  /** \brief Add a 3d text to the scene
569  * \param[in] text the text to add
570  * \param[in] position the world position where the text should be added
571  * \param[in] orientation the angles of rotation of the text around X, Y and Z axis,
572  in this order. The way the rotations are effectively done is the
573  Z-X-Y intrinsic rotations:
574  https://en.wikipedia.org/wiki/Euler_angles#Definition_by_intrinsic_rotations
575  * \param[in] textScale the scale of the text to render
576  * \param[in] r the red color value
577  * \param[in] g the green color value
578  * \param[in] b the blue color value
579  * \param[in] id the text object id (default: equal to the "text" parameter)
580  * \param[in] viewport the view port (default: all)
581  */
582  template <typename PointT> bool
583  addText3D (const std::string &text,
584  const PointT &position,
585  double orientation[3],
586  double textScale = 1.0,
587  double r = 1.0, double g = 1.0, double b = 1.0,
588  const std::string &id = "", int viewport = 0);
589 
590  /** \brief Check if the cloud, shape, or coordinate with the given id was already added to this visualizer.
591  * \param[in] id the id of the cloud, shape, or coordinate to check
592  * \return true if a cloud, shape, or coordinate with the specified id was found
593  */
594  inline bool
595  contains(const std::string &id) const
596  {
597  return (cloud_actor_map_->find (id) != cloud_actor_map_->end () ||
598  shape_actor_map_->find (id) != shape_actor_map_->end () ||
599  coordinate_actor_map_->find (id) != coordinate_actor_map_-> end());
600  }
601 
602  /** \brief Add the estimated surface normals of a Point Cloud to screen.
603  * \param[in] cloud the input point cloud dataset containing XYZ data and normals
604  * \param[in] level display only every level'th point (default: 100)
605  * \param[in] scale the normal arrow scale (default: 0.02m)
606  * \param[in] id the point cloud object id (default: cloud)
607  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
608  */
609  template <typename PointNT> bool
610  addPointCloudNormals (const typename pcl::PointCloud<PointNT>::ConstPtr &cloud,
611  int level = 100, float scale = 0.02f,
612  const std::string &id = "cloud", int viewport = 0);
613 
614  /** \brief Add the estimated surface normals of a Point Cloud to screen.
615  * \param[in] cloud the input point cloud dataset containing the XYZ data
616  * \param[in] normals the input point cloud dataset containing the normal data
617  * \param[in] level display only every level'th point (default: 100)
618  * \param[in] scale the normal arrow scale (default: 0.02m)
619  * \param[in] id the point cloud object id (default: cloud)
620  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
621  */
622  template <typename PointT, typename PointNT> bool
623  addPointCloudNormals (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
624  const typename pcl::PointCloud<PointNT>::ConstPtr &normals,
625  int level = 100, float scale = 0.02f,
626  const std::string &id = "cloud", int viewport = 0);
627 
628  /** \brief Add the estimated principal curvatures of a Point Cloud to screen.
629  * \param[in] cloud the input point cloud dataset containing the XYZ data and normals
630  * \param[in] pcs the input point cloud dataset containing the principal curvatures data
631  * \param[in] level display only every level'th point. Default: 100
632  * \param[in] scale the normal arrow scale. Default: 1.0
633  * \param[in] id the point cloud object id. Default: "cloud"
634  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
635  */
636  template <typename PointNT> bool
637  addPointCloudPrincipalCurvatures (
638  const typename pcl::PointCloud<PointNT>::ConstPtr &cloud,
639  const typename pcl::PointCloud<pcl::PrincipalCurvatures>::ConstPtr &pcs,
640  int level = 100, float scale = 1.0f,
641  const std::string &id = "cloud", int viewport = 0);
642 
643  /** \brief Add the estimated principal curvatures of a Point Cloud to screen.
644  * \param[in] cloud the input point cloud dataset containing the XYZ data
645  * \param[in] normals the input point cloud dataset containing the normal data
646  * \param[in] pcs the input point cloud dataset containing the principal curvatures data
647  * \param[in] level display only every level'th point. Default: 100
648  * \param[in] scale the normal arrow scale. Default: 1.0
649  * \param[in] id the point cloud object id. Default: "cloud"
650  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
651  */
652  template <typename PointT, typename PointNT> bool
653  addPointCloudPrincipalCurvatures (
654  const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
655  const typename pcl::PointCloud<PointNT>::ConstPtr &normals,
656  const pcl::PointCloud<pcl::PrincipalCurvatures>::ConstPtr &pcs,
657  int level = 100, float scale = 1.0f,
658  const std::string &id = "cloud", int viewport = 0);
659 
660  /** \brief Add the estimated surface intensity gradients of a Point Cloud to screen.
661  * \param[in] cloud the input point cloud dataset containing the XYZ data
662  * \param[in] gradients the input point cloud dataset containing the intensity gradient data
663  * \param[in] level display only every level'th point (default: 100)
664  * \param[in] scale the intensity gradient arrow scale (default: 1e-6m)
665  * \param[in] id the point cloud object id (default: cloud)
666  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
667  */
668  template <typename PointT, typename GradientT> bool
669  addPointCloudIntensityGradients (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
670  const typename pcl::PointCloud<GradientT>::ConstPtr &gradients,
671  int level = 100, double scale = 1e-6,
672  const std::string &id = "cloud", int viewport = 0);
673 
674  /** \brief Add a Point Cloud (templated) to screen.
675  * \param[in] cloud the input point cloud dataset
676  * \param[in] id the point cloud object id (default: cloud)
677  * \param viewport the view port where the Point Cloud should be added (default: all)
678  */
679  template <typename PointT> bool
680  addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
681  const std::string &id = "cloud", int viewport = 0);
682 
683  /** \brief Updates the XYZ data for an existing cloud object id on screen.
684  * \param[in] cloud the input point cloud dataset
685  * \param[in] id the point cloud object id to update (default: cloud)
686  * \return false if no cloud with the specified ID was found
687  */
688  template <typename PointT> bool
689  updatePointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
690  const std::string &id = "cloud");
691 
692  /** \brief Updates the XYZ data for an existing cloud object id on screen.
693  * \param[in] cloud the input point cloud dataset
694  * \param[in] geometry_handler the geometry handler to use
695  * \param[in] id the point cloud object id to update (default: cloud)
696  * \return false if no cloud with the specified ID was found
697  */
698  template <typename PointT> bool
699  updatePointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
700  const PointCloudGeometryHandler<PointT> &geometry_handler,
701  const std::string &id = "cloud");
702 
703  /** \brief Updates the XYZ data for an existing cloud object id on screen.
704  * \param[in] cloud the input point cloud dataset
705  * \param[in] color_handler the color handler to use
706  * \param[in] id the point cloud object id to update (default: cloud)
707  * \return false if no cloud with the specified ID was found
708  */
709  template <typename PointT> bool
710  updatePointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
711  const PointCloudColorHandler<PointT> &color_handler,
712  const std::string &id = "cloud");
713 
714  /** \brief Add a Point Cloud (templated) to screen.
715  * \param[in] cloud the input point cloud dataset
716  * \param[in] geometry_handler use a geometry handler object to extract the XYZ data
717  * \param[in] id the point cloud object id (default: cloud)
718  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
719  */
720  template <typename PointT> bool
721  addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
722  const PointCloudGeometryHandler<PointT> &geometry_handler,
723  const std::string &id = "cloud", int viewport = 0);
724 
725  /** \brief Add a Point Cloud (templated) to screen.
726  *
727  * Because the geometry handler is given as a pointer, it will be pushed back to the list of available
728  * handlers, rather than replacing the current active geometric handler. This makes it possible to
729  * switch between different geometric handlers 'on-the-fly' at runtime, from the PCLVisualizer
730  * interactor interface (using Alt+0..9).
731  *
732  * \param[in] cloud the input point cloud dataset
733  * \param[in] geometry_handler use a geometry handler object to extract the XYZ data
734  * \param[in] id the point cloud object id (default: cloud)
735  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
736  */
737  template <typename PointT> bool
738  addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
739  const GeometryHandlerConstPtr &geometry_handler,
740  const std::string &id = "cloud", int viewport = 0);
741 
742  /** \brief Add a Point Cloud (templated) to screen.
743  * \param[in] cloud the input point cloud dataset
744  * \param[in] color_handler a specific PointCloud visualizer handler for colors
745  * \param[in] id the point cloud object id (default: cloud)
746  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
747  */
748  template <typename PointT> bool
749  addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
750  const PointCloudColorHandler<PointT> &color_handler,
751  const std::string &id = "cloud", int viewport = 0);
752 
753  /** \brief Add a Point Cloud (templated) to screen.
754  *
755  * Because the color handler is given as a pointer, it will be pushed back to the list of available
756  * handlers, rather than replacing the current active color handler. This makes it possible to
757  * switch between different color handlers 'on-the-fly' at runtime, from the PCLVisualizer
758  * interactor interface (using 0..9).
759  *
760  * \param[in] cloud the input point cloud dataset
761  * \param[in] color_handler a specific PointCloud visualizer handler for colors
762  * \param[in] id the point cloud object id (default: cloud)
763  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
764  */
765  template <typename PointT> bool
766  addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
767  const ColorHandlerConstPtr &color_handler,
768  const std::string &id = "cloud", int viewport = 0);
769 
770  /** \brief Add a Point Cloud (templated) to screen.
771  *
772  * Because the geometry/color handler is given as a pointer, it will be pushed back to the list of
773  * available handlers, rather than replacing the current active handler. This makes it possible to
774  * switch between different handlers 'on-the-fly' at runtime, from the PCLVisualizer interactor
775  * interface (using [Alt+]0..9).
776  *
777  * \param[in] cloud the input point cloud dataset
778  * \param[in] geometry_handler a specific PointCloud visualizer handler for geometry
779  * \param[in] color_handler a specific PointCloud visualizer handler for colors
780  * \param[in] id the point cloud object id (default: cloud)
781  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
782  */
783  template <typename PointT> bool
784  addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
785  const GeometryHandlerConstPtr &geometry_handler,
786  const ColorHandlerConstPtr &color_handler,
787  const std::string &id = "cloud", int viewport = 0);
788 
789  /** \brief Add a binary blob Point Cloud to screen.
790  *
791  * Because the geometry/color handler is given as a pointer, it will be pushed back to the list of
792  * available handlers, rather than replacing the current active handler. This makes it possible to
793  * switch between different handlers 'on-the-fly' at runtime, from the PCLVisualizer interactor
794  * interface (using [Alt+]0..9).
795  *
796  * \param[in] cloud the input point cloud dataset
797  * \param[in] geometry_handler a specific PointCloud visualizer handler for geometry
798  * \param[in] color_handler a specific PointCloud visualizer handler for colors
799  * \param[in] sensor_origin the origin of the cloud data in global coordinates (defaults to 0,0,0)
800  * \param[in] sensor_orientation the orientation of the cloud data in global coordinates (defaults to 1,0,0,0)
801  * \param[in] id the point cloud object id (default: cloud)
802  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
803  */
804  bool
805  addPointCloud (const pcl::PCLPointCloud2::ConstPtr &cloud,
806  const GeometryHandlerConstPtr &geometry_handler,
807  const ColorHandlerConstPtr &color_handler,
808  const Eigen::Vector4f& sensor_origin,
809  const Eigen::Quaternion<float>& sensor_orientation,
810  const std::string &id = "cloud", int viewport = 0);
811 
812  /** \brief Add a binary blob Point Cloud to screen.
813  *
814  * Because the geometry/color handler is given as a pointer, it will be pushed back to the list of
815  * available handlers, rather than replacing the current active handler. This makes it possible to
816  * switch between different handlers 'on-the-fly' at runtime, from the PCLVisualizer interactor
817  * interface (using [Alt+]0..9).
818  *
819  * \param[in] cloud the input point cloud dataset
820  * \param[in] geometry_handler a specific PointCloud visualizer handler for geometry
821  * \param[in] sensor_origin the origin of the cloud data in global coordinates (defaults to 0,0,0)
822  * \param[in] sensor_orientation the orientation of the cloud data in global coordinates (defaults to 1,0,0,0)
823  * \param[in] id the point cloud object id (default: cloud)
824  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
825  */
826  bool
827  addPointCloud (const pcl::PCLPointCloud2::ConstPtr &cloud,
828  const GeometryHandlerConstPtr &geometry_handler,
829  const Eigen::Vector4f& sensor_origin,
830  const Eigen::Quaternion<float>& sensor_orientation,
831  const std::string &id = "cloud", int viewport = 0);
832 
833  /** \brief Add a binary blob Point Cloud to screen.
834  *
835  * Because the geometry/color handler is given as a pointer, it will be pushed back to the list of
836  * available handlers, rather than replacing the current active handler. This makes it possible to
837  * switch between different handlers 'on-the-fly' at runtime, from the PCLVisualizer interactor
838  * interface (using [Alt+]0..9).
839  *
840  * \param[in] cloud the input point cloud dataset
841  * \param[in] color_handler a specific PointCloud visualizer handler for colors
842  * \param[in] sensor_origin the origin of the cloud data in global coordinates (defaults to 0,0,0)
843  * \param[in] sensor_orientation the orientation of the cloud data in global coordinates (defaults to 1,0,0,0)
844  * \param[in] id the point cloud object id (default: cloud)
845  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
846  */
847  bool
848  addPointCloud (const pcl::PCLPointCloud2::ConstPtr &cloud,
849  const ColorHandlerConstPtr &color_handler,
850  const Eigen::Vector4f& sensor_origin,
851  const Eigen::Quaternion<float>& sensor_orientation,
852  const std::string &id = "cloud", int viewport = 0);
853 
854  /** \brief Add a Point Cloud (templated) to screen.
855  * \param[in] cloud the input point cloud dataset
856  * \param[in] color_handler a specific PointCloud visualizer handler for colors
857  * \param[in] geometry_handler use a geometry handler object to extract the XYZ data
858  * \param[in] id the point cloud object id (default: cloud)
859  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
860  */
861  template <typename PointT> bool
862  addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
863  const PointCloudColorHandler<PointT> &color_handler,
864  const PointCloudGeometryHandler<PointT> &geometry_handler,
865  const std::string &id = "cloud", int viewport = 0);
866 
867  /** \brief Add a PointXYZ Point Cloud to screen.
868  * \param[in] cloud the input point cloud dataset
869  * \param[in] id the point cloud object id (default: cloud)
870  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
871  */
872  inline bool
873  addPointCloud (const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &cloud,
874  const std::string &id = "cloud", int viewport = 0)
875  {
876  return (addPointCloud<pcl::PointXYZ> (cloud, id, viewport));
877  }
878 
879 
880  /** \brief Add a PointXYZRGB Point Cloud to screen.
881  * \param[in] cloud the input point cloud dataset
882  * \param[in] id the point cloud object id (default: cloud)
883  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
884  */
885  inline bool
886  addPointCloud (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr &cloud,
887  const std::string &id = "cloud", int viewport = 0)
888  {
889  pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> color_handler (cloud);
890  return (addPointCloud<pcl::PointXYZRGB> (cloud, color_handler, id, viewport));
891  }
892 
893  /** \brief Add a PointXYZRGBA Point Cloud to screen.
894  * \param[in] cloud the input point cloud dataset
895  * \param[in] id the point cloud object id (default: cloud)
896  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
897  */
898  inline bool
899  addPointCloud (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud,
900  const std::string &id = "cloud", int viewport = 0)
901  {
902  pcl::visualization::PointCloudColorHandlerRGBAField<pcl::PointXYZRGBA> color_handler (cloud);
903  return (addPointCloud<pcl::PointXYZRGBA> (cloud, color_handler, id, viewport));
904  }
905 
906  /** \brief Add a PointXYZL Point Cloud to screen.
907  * \param[in] cloud the input point cloud dataset
908  * \param[in] id the point cloud object id (default: cloud)
909  * \param[in] viewport the view port where the Point Cloud should be added (default: all)
910  */
911  inline bool
912  addPointCloud (const pcl::PointCloud<pcl::PointXYZL>::ConstPtr &cloud,
913  const std::string &id = "cloud", int viewport = 0)
914  {
915  pcl::visualization::PointCloudColorHandlerLabelField<pcl::PointXYZL> color_handler (cloud);
916  return (addPointCloud<pcl::PointXYZL> (cloud, color_handler, id, viewport));
917  }
918 
919  /** \brief Updates the XYZ data for an existing cloud object id on screen.
920  * \param[in] cloud the input point cloud dataset
921  * \param[in] id the point cloud object id to update (default: cloud)
922  * \return false if no cloud with the specified ID was found
923  */
924  inline bool
925  updatePointCloud (const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &cloud,
926  const std::string &id = "cloud")
927  {
928  return (updatePointCloud<pcl::PointXYZ> (cloud, id));
929  }
930 
931  /** \brief Updates the XYZRGB data for an existing cloud object id on screen.
932  * \param[in] cloud the input point cloud dataset
933  * \param[in] id the point cloud object id to update (default: cloud)
934  * \return false if no cloud with the specified ID was found
935  */
936  inline bool
937  updatePointCloud (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr &cloud,
938  const std::string &id = "cloud")
939  {
940  pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> color_handler (cloud);
941  return (updatePointCloud<pcl::PointXYZRGB> (cloud, color_handler, id));
942  }
943 
944  /** \brief Updates the XYZRGBA data for an existing cloud object id on screen.
945  * \param[in] cloud the input point cloud dataset
946  * \param[in] id the point cloud object id to update (default: cloud)
947  * \return false if no cloud with the specified ID was found
948  */
949  inline bool
950  updatePointCloud (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud,
951  const std::string &id = "cloud")
952  {
953  pcl::visualization::PointCloudColorHandlerRGBAField<pcl::PointXYZRGBA> color_handler (cloud);
954  return (updatePointCloud<pcl::PointXYZRGBA> (cloud, color_handler, id));
955  }
956 
957  /** \brief Updates the XYZL data for an existing cloud object id on screen.
958  * \param[in] cloud the input point cloud dataset
959  * \param[in] id the point cloud object id to update (default: cloud)
960  * \return false if no cloud with the specified ID was found
961  */
962  inline bool
963  updatePointCloud (const pcl::PointCloud<pcl::PointXYZL>::ConstPtr &cloud,
964  const std::string &id = "cloud")
965  {
966  pcl::visualization::PointCloudColorHandlerLabelField<pcl::PointXYZL> color_handler (cloud);
967  return (updatePointCloud<pcl::PointXYZL> (cloud, color_handler, id));
968  }
969 
970  /** \brief Add a PolygonMesh object to screen
971  * \param[in] polymesh the polygonal mesh
972  * \param[in] id the polygon object id (default: "polygon")
973  * \param[in] viewport the view port where the PolygonMesh should be added (default: all)
974  */
975  bool
976  addPolygonMesh (const pcl::PolygonMesh &polymesh,
977  const std::string &id = "polygon",
978  int viewport = 0);
979 
980  /** \brief Add a PolygonMesh object to screen
981  * \param[in] cloud the polygonal mesh point cloud
982  * \param[in] vertices the polygonal mesh vertices
983  * \param[in] id the polygon object id (default: "polygon")
984  * \param[in] viewport the view port where the PolygonMesh should be added (default: all)
985  */
986  template <typename PointT> bool
987  addPolygonMesh (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
988  const std::vector<pcl::Vertices> &vertices,
989  const std::string &id = "polygon",
990  int viewport = 0);
991 
992  /** \brief Update a PolygonMesh object on screen
993  * \param[in] cloud the polygonal mesh point cloud
994  * \param[in] vertices the polygonal mesh vertices
995  * \param[in] id the polygon object id (default: "polygon")
996  * \return false if no polygonmesh with the specified ID was found
997  */
998  template <typename PointT> bool
999  updatePolygonMesh (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
1000  const std::vector<pcl::Vertices> &vertices,
1001  const std::string &id = "polygon");
1002 
1003  /** \brief Update a PolygonMesh object on screen
1004  * \param[in] polymesh the polygonal mesh
1005  * \param[in] id the polygon object id (default: "polygon")
1006  * \return false if no polygonmesh with the specified ID was found
1007  */
1008  bool
1009  updatePolygonMesh (const pcl::PolygonMesh &polymesh,
1010  const std::string &id = "polygon");
1011 
1012  /** \brief Add a Polygonline from a polygonMesh object to screen
1013  * \param[in] polymesh the polygonal mesh from where the polylines will be extracted
1014  * \param[in] id the polygon object id (default: "polygon")
1015  * \param[in] viewport the view port where the PolygonMesh should be added (default: all)
1016  */
1017  bool
1018  addPolylineFromPolygonMesh (const pcl::PolygonMesh &polymesh,
1019  const std::string &id = "polyline",
1020  int viewport = 0);
1021 
1022  /** \brief Add the specified correspondences to the display.
1023  * \param[in] source_points The source points
1024  * \param[in] target_points The target points
1025  * \param[in] correspondences The mapping from source points to target points. Each element must be an index into target_points
1026  * \param[in] id the polygon object id (default: "correspondences")
1027  * \param[in] viewport the view port where the correspondences should be added (default: all)
1028  */
1029  template <typename PointT> bool
1030  addCorrespondences (const typename pcl::PointCloud<PointT>::ConstPtr &source_points,
1031  const typename pcl::PointCloud<PointT>::ConstPtr &target_points,
1032  const std::vector<int> & correspondences,
1033  const std::string &id = "correspondences",
1034  int viewport = 0);
1035 
1036  /** \brief Add a TextureMesh object to screen
1037  * \param[in] polymesh the textured polygonal mesh
1038  * \param[in] id the texture mesh object id (default: "texture")
1039  * \param[in] viewport the view port where the TextureMesh should be added (default: all)
1040  */
1041  bool
1042  addTextureMesh (const pcl::TextureMesh &polymesh,
1043  const std::string &id = "texture",
1044  int viewport = 0);
1045 
1046  /** \brief Add the specified correspondences to the display.
1047  * \param[in] source_points The source points
1048  * \param[in] target_points The target points
1049  * \param[in] correspondences The mapping from source points to target points. Each element must be an index into target_points
1050  * \param[in] nth display only the Nth correspondence (e.g., skip the rest)
1051  * \param[in] id the polygon object id (default: "correspondences")
1052  * \param[in] viewport the view port where the correspondences should be added (default: all)
1053  * \param[in] overwrite allow to overwrite already existing correspondences
1054  */
1055  template <typename PointT> bool
1056  addCorrespondences (const typename pcl::PointCloud<PointT>::ConstPtr &source_points,
1057  const typename pcl::PointCloud<PointT>::ConstPtr &target_points,
1058  const pcl::Correspondences &correspondences,
1059  int nth,
1060  const std::string &id = "correspondences",
1061  int viewport = 0,
1062  bool overwrite = false);
1063 
1064  /** \brief Add the specified correspondences to the display.
1065  * \param[in] source_points The source points
1066  * \param[in] target_points The target points
1067  * \param[in] correspondences The mapping from source points to target points. Each element must be an index into target_points
1068  * \param[in] id the polygon object id (default: "correspondences")
1069  * \param[in] viewport the view port where the correspondences should be added (default: all)
1070  */
1071  template <typename PointT> bool
1072  addCorrespondences (const typename pcl::PointCloud<PointT>::ConstPtr &source_points,
1073  const typename pcl::PointCloud<PointT>::ConstPtr &target_points,
1074  const pcl::Correspondences &correspondences,
1075  const std::string &id = "correspondences",
1076  int viewport = 0)
1077  {
1078  // If Nth not given, display all correspondences
1079  return (addCorrespondences<PointT> (source_points, target_points,
1080  correspondences, 1, id, viewport));
1081  }
1082 
1083  /** \brief Update the specified correspondences to the display.
1084  * \param[in] source_points The source points
1085  * \param[in] target_points The target points
1086  * \param[in] correspondences The mapping from source points to target points. Each element must be an index into target_points
1087  * \param[in] nth display only the Nth correspondence (e.g., skip the rest)
1088  * \param[in] id the polygon object id (default: "correspondences")
1089  * \param[in] viewport the view port where the correspondences should be updated (default: all)
1090  */
1091  template <typename PointT> bool
1092  updateCorrespondences (
1093  const typename pcl::PointCloud<PointT>::ConstPtr &source_points,
1094  const typename pcl::PointCloud<PointT>::ConstPtr &target_points,
1095  const pcl::Correspondences &correspondences,
1096  int nth,
1097  const std::string &id = "correspondences",
1098  int viewport = 0);
1099 
1100  /** \brief Update the specified correspondences to the display.
1101  * \param[in] source_points The source points
1102  * \param[in] target_points The target points
1103  * \param[in] correspondences The mapping from source points to target points. Each element must be an index into target_points
1104  * \param[in] id the polygon object id (default: "correspondences")
1105  * \param[in] viewport the view port where the correspondences should be updated (default: all)
1106  */
1107  template <typename PointT> bool
1108  updateCorrespondences (
1109  const typename pcl::PointCloud<PointT>::ConstPtr &source_points,
1110  const typename pcl::PointCloud<PointT>::ConstPtr &target_points,
1111  const pcl::Correspondences &correspondences,
1112  const std::string &id = "correspondences",
1113  int viewport = 0)
1114  {
1115  // If Nth not given, display all correspondences
1116  return (updateCorrespondences<PointT> (source_points, target_points,
1117  correspondences, 1, id, viewport));
1118  }
1119 
1120  /** \brief Remove the specified correspondences from the display.
1121  * \param[in] id the polygon correspondences object id (i.e., given on \ref addCorrespondences)
1122  * \param[in] viewport view port from where the correspondences should be removed (default: all)
1123  */
1124  void
1125  removeCorrespondences (const std::string &id = "correspondences", int viewport = 0);
1126 
1127  /** \brief Get the color handler index of a rendered PointCloud based on its ID
1128  * \param[in] id the point cloud object id
1129  */
1130  int
1131  getColorHandlerIndex (const std::string &id);
1132 
1133  /** \brief Get the geometry handler index of a rendered PointCloud based on its ID
1134  * \param[in] id the point cloud object id
1135  */
1136  int
1137  getGeometryHandlerIndex (const std::string &id);
1138 
1139  /** \brief Update/set the color index of a rendered PointCloud based on its ID
1140  * \param[in] id the point cloud object id
1141  * \param[in] index the color handler index to use
1142  */
1143  bool
1144  updateColorHandlerIndex (const std::string &id, int index);
1145 
1146  /** \brief Set the rendering properties of a PointCloud (3x values - e.g., RGB)
1147  * \param[in] property the property type
1148  * \param[in] val1 the first value to be set
1149  * \param[in] val2 the second value to be set
1150  * \param[in] val3 the third value to be set
1151  * \param[in] id the point cloud object id (default: cloud)
1152  * \param[in] viewport the view port where the Point Cloud's rendering properties should be modified (default: all)
1153  * \note The list of properties can be found in \ref pcl::visualization::LookUpTableRepresentationProperties.
1154  */
1155  bool
1156  setPointCloudRenderingProperties (int property, double val1, double val2, double val3,
1157  const std::string &id = "cloud", int viewport = 0);
1158 
1159  /** \brief Set the rendering properties of a PointCloud (2x values - e.g., LUT minmax values)
1160  * \param[in] property the property type
1161  * \param[in] val1 the first value to be set
1162  * \param[in] val2 the second value to be set
1163  * \param[in] id the point cloud object id (default: cloud)
1164  * \param[in] viewport the view port where the Point Cloud's rendering properties should be modified (default: all)
1165  * \note The list of properties can be found in \ref pcl::visualization::LookUpTableRepresentationProperties.
1166  */
1167  bool
1168  setPointCloudRenderingProperties (int property, double val1, double val2,
1169  const std::string &id = "cloud", int viewport = 0);
1170 
1171  /** \brief Set the rendering properties of a PointCloud
1172  * \param[in] property the property type
1173  * \param[in] value the value to be set
1174  * \param[in] id the point cloud object id (default: cloud)
1175  * \param[in] viewport the view port where the Point Cloud's rendering properties should be modified (default: all)
1176  * \note The list of properties can be found in \ref pcl::visualization::LookUpTableRepresentationProperties.
1177  */
1178  bool
1179  setPointCloudRenderingProperties (int property, double value,
1180  const std::string &id = "cloud", int viewport = 0);
1181 
1182  /** \brief Get the rendering properties of a PointCloud
1183  * \param[in] property the property type
1184  * \param[in] value the resultant property value
1185  * \param[in] id the point cloud object id (default: cloud)
1186  * \note The list of properties can be found in \ref pcl::visualization::LookUpTableRepresentationProperties.
1187  */
1188  bool
1189  getPointCloudRenderingProperties (int property, double &value,
1190  const std::string &id = "cloud");
1191 
1192  /** \brief Get the rendering properties of a PointCloud
1193  * \param[in] property the property type
1194  * \param[out] val1 the resultant property value
1195  * \param[out] val2 the resultant property value
1196  * \param[out] val3 the resultant property value
1197  * \param[in] id the point cloud object id (default: cloud)
1198  * \return True if the property is effectively retrieved.
1199  * \note The list of properties can be found in \ref pcl::visualization::LookUpTableRepresentationProperties.
1200  */
1201  bool
1202  getPointCloudRenderingProperties (RenderingProperties property, double &val1, double &val2, double &val3,
1203  const std::string &id = "cloud");
1204 
1205  /** \brief Set whether the point cloud is selected or not
1206  * \param[in] selected whether the cloud is selected or not (true = selected)
1207  * \param[in] id the point cloud object id (default: cloud)
1208  */
1209  bool
1210  setPointCloudSelected (const bool selected, const std::string &id = "cloud" );
1211 
1212  /** \brief Set the rendering properties of a shape
1213  * \param[in] property the property type
1214  * \param[in] value the value to be set
1215  * \param[in] id the shape object id
1216  * \param[in] viewport the view port where the shape's properties should be modified (default: all)
1217  * \note When using \ref addPolygonMesh you you should use \ref setPointCloudRenderingProperties
1218  * \note The list of properties can be found in \ref pcl::visualization::LookUpTableRepresentationProperties.
1219  */
1220  bool
1221  setShapeRenderingProperties (int property, double value,
1222  const std::string &id, int viewport = 0);
1223 
1224  /** \brief Set the rendering properties of a shape (2x values - e.g., LUT minmax values)
1225  * \param[in] property the property type
1226  * \param[in] val1 the first value to be set
1227  * \param[in] val2 the second value to be set
1228  * \param[in] id the shape object id
1229  * \param[in] viewport the view port where the shape's properties should be modified (default: all)
1230  * \note When using \ref addPolygonMesh you you should use \ref setPointCloudRenderingProperties
1231  */
1232  bool
1233  setShapeRenderingProperties (int property, double val1, double val2,
1234  const std::string &id, int viewport = 0);
1235 
1236  /** \brief Set the rendering properties of a shape (3x values - e.g., RGB)
1237  * \param[in] property the property type
1238  * \param[in] val1 the first value to be set
1239  * \param[in] val2 the second value to be set
1240  * \param[in] val3 the third value to be set
1241  * \param[in] id the shape object id
1242  * \param[in] viewport the view port where the shape's properties should be modified (default: all)
1243  * \note When using \ref addPolygonMesh you you should use \ref setPointCloudRenderingProperties
1244  */
1245  bool
1246  setShapeRenderingProperties (int property, double val1, double val2, double val3,
1247  const std::string &id, int viewport = 0);
1248 
1249  /** \brief Returns true when the user tried to close the window */
1250  bool
1251  wasStopped () const;
1252 
1253  /** \brief Set the stopped flag back to false */
1254  void
1255  resetStoppedFlag ();
1256 
1257  /** \brief Stop the interaction and close the visualization window. */
1258  void
1259  close ();
1260 
1261  /** \brief Create a new viewport from [xmin,ymin] -> [xmax,ymax].
1262  * \param[in] xmin the minimum X coordinate for the viewport (0.0 <= 1.0)
1263  * \param[in] ymin the minimum Y coordinate for the viewport (0.0 <= 1.0)
1264  * \param[in] xmax the maximum X coordinate for the viewport (0.0 <= 1.0)
1265  * \param[in] ymax the maximum Y coordinate for the viewport (0.0 <= 1.0)
1266  * \param[in] viewport the id of the new viewport
1267  *
1268  * \note If no renderer for the current window exists, one will be created, and
1269  * the viewport will be set to 0 ('all'). In case one or multiple renderers do
1270  * exist, the viewport ID will be set to the total number of renderers - 1.
1271  */
1272  void
1273  createViewPort (double xmin, double ymin, double xmax, double ymax, int &viewport);
1274 
1275  /** \brief Create a new separate camera for the given viewport.
1276  * \param[in] viewport the viewport to create a new camera for.
1277  */
1278  void
1279  createViewPortCamera (const int viewport);
1280 
1281  /** \brief Add a polygon (polyline) that represents the input point cloud (connects all
1282  * points in order)
1283  * \param[in] cloud the point cloud dataset representing the polygon
1284  * \param[in] r the red channel of the color that the polygon should be rendered with
1285  * \param[in] g the green channel of the color that the polygon should be rendered with
1286  * \param[in] b the blue channel of the color that the polygon should be rendered with
1287  * \param[in] id (optional) the polygon id/name (default: "polygon")
1288  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1289  */
1290  template <typename PointT> bool
1291  addPolygon (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
1292  double r, double g, double b,
1293  const std::string &id = "polygon", int viewport = 0);
1294 
1295  /** \brief Add a polygon (polyline) that represents the input point cloud (connects all
1296  * points in order)
1297  * \param[in] cloud the point cloud dataset representing the polygon
1298  * \param[in] id the polygon id/name (default: "polygon")
1299  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1300  */
1301  template <typename PointT> bool
1302  addPolygon (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
1303  const std::string &id = "polygon",
1304  int viewport = 0);
1305 
1306  /** \brief Add a planar polygon that represents the input point cloud (connects all points in order)
1307  * \param[in] polygon the polygon to draw
1308  * \param[in] r the red channel of the color that the polygon should be rendered with
1309  * \param[in] g the green channel of the color that the polygon should be rendered with
1310  * \param[in] b the blue channel of the color that the polygon should be rendered with
1311  * \param[in] id the polygon id/name (default: "polygon")
1312  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1313  */
1314  template <typename PointT> bool
1315  addPolygon (const pcl::PlanarPolygon<PointT> &polygon,
1316  double r, double g, double b,
1317  const std::string &id = "polygon",
1318  int viewport = 0);
1319 
1320  /** \brief Add a line segment from two points
1321  * \param[in] pt1 the first (start) point on the line
1322  * \param[in] pt2 the second (end) point on the line
1323  * \param[in] id the line id/name (default: "line")
1324  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1325  */
1326  template <typename P1, typename P2> bool
1327  addLine (const P1 &pt1, const P2 &pt2, const std::string &id = "line",
1328  int viewport = 0);
1329 
1330  /** \brief Add a line segment from two points
1331  * \param[in] pt1 the first (start) point on the line
1332  * \param[in] pt2 the second (end) point on the line
1333  * \param[in] r the red channel of the color that the line should be rendered with
1334  * \param[in] g the green channel of the color that the line should be rendered with
1335  * \param[in] b the blue channel of the color that the line should be rendered with
1336  * \param[in] id the line id/name (default: "line")
1337  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1338  */
1339  template <typename P1, typename P2> bool
1340  addLine (const P1 &pt1, const P2 &pt2, double r, double g, double b,
1341  const std::string &id = "line", int viewport = 0);
1342 
1343  /** \brief Add a line arrow segment between two points, and display the distance between them
1344  *
1345  * Arrow heads are attached to both end points of the arrow.
1346  *
1347  * \param[in] pt1 the first (start) point on the line
1348  * \param[in] pt2 the second (end) point on the line
1349  * \param[in] r the red channel of the color that the line should be rendered with
1350  * \param[in] g the green channel of the color that the line should be rendered with
1351  * \param[in] b the blue channel of the color that the line should be rendered with
1352  * \param[in] id the arrow id/name (default: "arrow")
1353  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1354  */
1355  template <typename P1, typename P2> bool
1356  addArrow (const P1 &pt1, const P2 &pt2, double r, double g, double b,
1357  const std::string &id = "arrow", int viewport = 0);
1358 
1359  /** \brief Add a line arrow segment between two points, and (optionally) display the distance between them
1360  *
1361  * Arrow head is attached on the **start** point (\c pt1) of the arrow.
1362  *
1363  * \param[in] pt1 the first (start) point on the line
1364  * \param[in] pt2 the second (end) point on the line
1365  * \param[in] r the red channel of the color that the line should be rendered with
1366  * \param[in] g the green channel of the color that the line should be rendered with
1367  * \param[in] b the blue channel of the color that the line should be rendered with
1368  * \param[in] display_length true if the length should be displayed on the arrow as text
1369  * \param[in] id the line id/name (default: "arrow")
1370  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1371  */
1372  template <typename P1, typename P2> bool
1373  addArrow (const P1 &pt1, const P2 &pt2, double r, double g, double b, bool display_length,
1374  const std::string &id = "arrow", int viewport = 0);
1375 
1376  /** \brief Add a line arrow segment between two points, and display the distance between them in a given color
1377  *
1378  * Arrow heads are attached to both end points of the arrow.
1379  *
1380  * \param[in] pt1 the first (start) point on the line
1381  * \param[in] pt2 the second (end) point on the line
1382  * \param[in] r_line the red channel of the color that the line should be rendered with
1383  * \param[in] g_line the green channel of the color that the line should be rendered with
1384  * \param[in] b_line the blue channel of the color that the line should be rendered with
1385  * \param[in] r_text the red channel of the color that the text should be rendered with
1386  * \param[in] g_text the green channel of the color that the text should be rendered with
1387  * \param[in] b_text the blue channel of the color that the text should be rendered with
1388  * \param[in] id the line id/name (default: "arrow")
1389  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1390  */
1391  template <typename P1, typename P2> bool
1392  addArrow (const P1 &pt1, const P2 &pt2,
1393  double r_line, double g_line, double b_line,
1394  double r_text, double g_text, double b_text,
1395  const std::string &id = "arrow", int viewport = 0);
1396 
1397 
1398  /** \brief Add a sphere shape from a point and a radius
1399  * \param[in] center the center of the sphere
1400  * \param[in] radius the radius of the sphere
1401  * \param[in] id the sphere id/name (default: "sphere")
1402  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1403  */
1404  template <typename PointT> bool
1405  addSphere (const PointT &center, double radius, const std::string &id = "sphere",
1406  int viewport = 0);
1407 
1408  /** \brief Add a sphere shape from a point and a radius
1409  * \param[in] center the center of the sphere
1410  * \param[in] radius the radius of the sphere
1411  * \param[in] r the red channel of the color that the sphere should be rendered with
1412  * \param[in] g the green channel of the color that the sphere should be rendered with
1413  * \param[in] b the blue channel of the color that the sphere should be rendered with
1414  * \param[in] id the sphere id/name (default: "sphere")
1415  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1416  */
1417  template <typename PointT> bool
1418  addSphere (const PointT &center, double radius, double r, double g, double b,
1419  const std::string &id = "sphere", int viewport = 0);
1420 
1421  /** \brief Update an existing sphere shape from a point and a radius
1422  * \param[in] center the center of the sphere
1423  * \param[in] radius the radius of the sphere
1424  * \param[in] r the red channel of the color that the sphere should be rendered with
1425  * \param[in] g the green channel of the color that the sphere should be rendered with
1426  * \param[in] b the blue channel of the color that the sphere should be rendered with
1427  * \param[in] id the sphere id/name (default: "sphere")
1428  */
1429  template <typename PointT> bool
1430  updateSphere (const PointT &center, double radius, double r, double g, double b,
1431  const std::string &id = "sphere");
1432 
1433  /** \brief Add a vtkPolydata as a mesh
1434  * \param[in] polydata vtkPolyData
1435  * \param[in] id the model id/name (default: "PolyData")
1436  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1437  */
1438  bool
1439  addModelFromPolyData (vtkSmartPointer<vtkPolyData> polydata,
1440  const std::string & id = "PolyData",
1441  int viewport = 0);
1442 
1443  /** \brief Add a vtkPolydata as a mesh
1444  * \param[in] polydata vtkPolyData
1445  * \param[in] transform transformation to apply
1446  * \param[in] id the model id/name (default: "PolyData")
1447  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1448  */
1449  bool
1450  addModelFromPolyData (vtkSmartPointer<vtkPolyData> polydata,
1451  vtkSmartPointer<vtkTransform> transform,
1452  const std::string &id = "PolyData",
1453  int viewport = 0);
1454 
1455  /** \brief Add a PLYmodel as a mesh
1456  * \param[in] filename of the ply file
1457  * \param[in] id the model id/name (default: "PLYModel")
1458  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1459  */
1460  bool
1461  addModelFromPLYFile (const std::string &filename,
1462  const std::string &id = "PLYModel",
1463  int viewport = 0);
1464 
1465  /** \brief Add a PLYmodel as a mesh and applies given transformation
1466  * \param[in] filename of the ply file
1467  * \param[in] transform transformation to apply
1468  * \param[in] id the model id/name (default: "PLYModel")
1469  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1470  */
1471  bool
1472  addModelFromPLYFile (const std::string &filename,
1473  vtkSmartPointer<vtkTransform> transform,
1474  const std::string &id = "PLYModel",
1475  int viewport = 0);
1476 
1477  /** \brief Add a cylinder from a set of given model coefficients
1478  * \param[in] coefficients the model coefficients (point_on_axis, axis_direction, radius)
1479  * \param[in] id the cylinder id/name (default: "cylinder")
1480  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1481  *
1482  * \code
1483  * // The following are given (or computed using sample consensus techniques)
1484  * // See SampleConsensusModelCylinder for more information.
1485  * // Eigen::Vector3f pt_on_axis, axis_direction;
1486  * // float radius;
1487  *
1488  * pcl::ModelCoefficients cylinder_coeff;
1489  * cylinder_coeff.values.resize (7); // We need 7 values
1490  * cylinder_coeff.values[0] = pt_on_axis.x ();
1491  * cylinder_coeff.values[1] = pt_on_axis.y ();
1492  * cylinder_coeff.values[2] = pt_on_axis.z ();
1493  *
1494  * cylinder_coeff.values[3] = axis_direction.x ();
1495  * cylinder_coeff.values[4] = axis_direction.y ();
1496  * cylinder_coeff.values[5] = axis_direction.z ();
1497  *
1498  * cylinder_coeff.values[6] = radius;
1499  *
1500  * addCylinder (cylinder_coeff);
1501  * \endcode
1502  */
1503  bool
1504  addCylinder (const pcl::ModelCoefficients &coefficients,
1505  const std::string &id = "cylinder",
1506  int viewport = 0);
1507 
1508  /** \brief Add a sphere from a set of given model coefficients
1509  * \param[in] coefficients the model coefficients (sphere center, radius)
1510  * \param[in] id the sphere id/name (default: "sphere")
1511  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1512  *
1513  * \code
1514  * // The following are given (or computed using sample consensus techniques)
1515  * // See SampleConsensusModelSphere for more information
1516  * // Eigen::Vector3f sphere_center;
1517  * // float radius;
1518  *
1519  * pcl::ModelCoefficients sphere_coeff;
1520  * sphere_coeff.values.resize (4); // We need 4 values
1521  * sphere_coeff.values[0] = sphere_center.x ();
1522  * sphere_coeff.values[1] = sphere_center.y ();
1523  * sphere_coeff.values[2] = sphere_center.z ();
1524  *
1525  * sphere_coeff.values[3] = radius;
1526  *
1527  * addSphere (sphere_coeff);
1528  * \endcode
1529  */
1530  bool
1531  addSphere (const pcl::ModelCoefficients &coefficients,
1532  const std::string &id = "sphere",
1533  int viewport = 0);
1534 
1535  /** \brief Add a line from a set of given model coefficients
1536  * \param[in] coefficients the model coefficients (point_on_line, direction)
1537  * \param[in] id the line id/name (default: "line")
1538  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1539  *
1540  * \code
1541  * // The following are given (or computed using sample consensus techniques)
1542  * // See SampleConsensusModelLine for more information
1543  * // Eigen::Vector3f point_on_line, line_direction;
1544  *
1545  * pcl::ModelCoefficients line_coeff;
1546  * line_coeff.values.resize (6); // We need 6 values
1547  * line_coeff.values[0] = point_on_line.x ();
1548  * line_coeff.values[1] = point_on_line.y ();
1549  * line_coeff.values[2] = point_on_line.z ();
1550  *
1551  * line_coeff.values[3] = line_direction.x ();
1552  * line_coeff.values[4] = line_direction.y ();
1553  * line_coeff.values[5] = line_direction.z ();
1554  *
1555  * addLine (line_coeff);
1556  * \endcode
1557  */
1558  bool
1559  addLine (const pcl::ModelCoefficients &coefficients,
1560  const std::string &id = "line",
1561  int viewport = 0);
1562 
1563  /** \brief Add a line from a set of given model coefficients
1564  * \param[in] coefficients the model coefficients (point_on_line, direction)
1565  * \param[in] id the line id/name (default: "line")
1566  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1567  *
1568  * \code
1569  * // The following are given (or computed using sample consensus techniques)
1570  * // See SampleConsensusModelLine for more information
1571  * // Eigen::Vector3f point_on_line, line_direction;
1572  *
1573  * pcl::ModelCoefficients line_coeff;
1574  * line_coeff.values.resize (6); // We need 6 values
1575  * line_coeff.values[0] = point_on_line.x ();
1576  * line_coeff.values[1] = point_on_line.y ();
1577  * line_coeff.values[2] = point_on_line.z ();
1578  *
1579  * line_coeff.values[3] = line_direction.x ();
1580  * line_coeff.values[4] = line_direction.y ();
1581  * line_coeff.values[5] = line_direction.z ();
1582  *
1583  * addLine (line_coeff);
1584  * \endcode
1585  */
1586  bool
1587  addLine (const pcl::ModelCoefficients &coefficients,
1588  const char *id = "line",
1589  int viewport = 0)
1590  {
1591  return addLine (coefficients, std::string (id), viewport);
1592  }
1593 
1594  /** \brief Add a plane from a set of given model coefficients
1595  * \param[in] coefficients the model coefficients (a, b, c, d with ax+by+cz+d=0)
1596  * \param[in] id the plane id/name (default: "plane")
1597  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1598  *
1599  * \code
1600  * // The following are given (or computed using sample consensus techniques)
1601  * // See SampleConsensusModelPlane for more information
1602  * // Eigen::Vector4f plane_parameters;
1603  *
1604  * pcl::ModelCoefficients plane_coeff;
1605  * plane_coeff.values.resize (4); // We need 4 values
1606  * plane_coeff.values[0] = plane_parameters.x ();
1607  * plane_coeff.values[1] = plane_parameters.y ();
1608  * plane_coeff.values[2] = plane_parameters.z ();
1609  * plane_coeff.values[3] = plane_parameters.w ();
1610  *
1611  * addPlane (plane_coeff);
1612  * \endcode
1613  */
1614  bool
1615  addPlane (const pcl::ModelCoefficients &coefficients,
1616  const std::string &id = "plane",
1617  int viewport = 0);
1618 
1619  bool
1620  addPlane (const pcl::ModelCoefficients &coefficients, double x, double y, double z,
1621  const std::string &id = "plane",
1622  int viewport = 0);
1623  /** \brief Add a circle from a set of given model coefficients
1624  * \param[in] coefficients the model coefficients (x, y, radius)
1625  * \param[in] id the circle id/name (default: "circle")
1626  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1627  *
1628  * \code
1629  * // The following are given (or computed using sample consensus techniques)
1630  * // See SampleConsensusModelCircle2D for more information
1631  * // float x, y, radius;
1632  *
1633  * pcl::ModelCoefficients circle_coeff;
1634  * circle_coeff.values.resize (3); // We need 3 values
1635  * circle_coeff.values[0] = x;
1636  * circle_coeff.values[1] = y;
1637  * circle_coeff.values[2] = radius;
1638  *
1639  * vtkSmartPointer<vtkDataSet> data = pcl::visualization::create2DCircle (circle_coeff, z);
1640  * \endcode
1641  */
1642  bool
1643  addCircle (const pcl::ModelCoefficients &coefficients,
1644  const std::string &id = "circle",
1645  int viewport = 0);
1646 
1647  /** \brief Add a cone from a set of given model coefficients
1648  * \param[in] coefficients the model coefficients (see \ref pcl::visualization::createCone)
1649  * \param[in] id the cone id/name (default: "cone")
1650  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1651  */
1652  bool
1653  addCone (const pcl::ModelCoefficients &coefficients,
1654  const std::string &id = "cone",
1655  int viewport = 0);
1656 
1657  /** \brief Add a cube from a set of given model coefficients
1658  * \param[in] coefficients the model coefficients (see \ref pcl::visualization::createCube)
1659  * \param[in] id the cube id/name (default: "cube")
1660  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1661  */
1662  bool
1663  addCube (const pcl::ModelCoefficients &coefficients,
1664  const std::string &id = "cube",
1665  int viewport = 0);
1666 
1667  /** \brief Add a cube from a set of given model coefficients
1668  * \param[in] translation a translation to apply to the cube from 0,0,0
1669  * \param[in] rotation a quaternion-based rotation to apply to the cube
1670  * \param[in] width the cube's width
1671  * \param[in] height the cube's height
1672  * \param[in] depth the cube's depth
1673  * \param[in] id the cube id/name (default: "cube")
1674  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1675  */
1676  bool
1677  addCube (const Eigen::Vector3f &translation, const Eigen::Quaternionf &rotation,
1678  double width, double height, double depth,
1679  const std::string &id = "cube",
1680  int viewport = 0);
1681 
1682  /** \brief Add a cube
1683  * \param[in] x_min the min X coordinate
1684  * \param[in] x_max the max X coordinate
1685  * \param[in] y_min the min Y coordinate
1686  * \param[in] y_max the max Y coordinate
1687  * \param[in] z_min the min Z coordinate
1688  * \param[in] z_max the max Z coordinate
1689  * \param[in] r how much red (0.0 -> 1.0)
1690  * \param[in] g how much green (0.0 -> 1.0)
1691  * \param[in] b how much blue (0.0 -> 1.0)
1692  * \param[in] id the cube id/name (default: "cube")
1693  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1694  */
1695  bool
1696  addCube (float x_min, float x_max, float y_min, float y_max, float z_min, float z_max,
1697  double r = 1.0, double g = 1.0, double b = 1.0, const std::string &id = "cube", int viewport = 0);
1698 
1699  /** \brief Add an ellipsoid from the given parameters
1700  * \param[in] transform a transformation to apply to the ellipsoid from 0,0,0
1701  * \param[in] radius_x the ellipsoid's radius along its local x-axis
1702  * \param[in] radius_y the ellipsoid's radius along its local y-axis
1703  * \param[in] radius_z the ellipsoid's radius along its local z-axis
1704  * \param[in] id the ellipsoid id/name (default: "ellipsoid")
1705  * \param[in] viewport (optional) the id of the new viewport (default: 0)
1706  */
1707  bool
1708  addEllipsoid (const Eigen::Isometry3d &transform,
1709  double radius_x, double radius_y, double radius_z,
1710  const std::string &id = "ellipsoid",
1711  int viewport = 0);
1712 
1713  /**
1714  * @brief Eye-Dome Lighting makes dark areas to improve depth perception
1715  * See https://www.kitware.com/eye-dome-lighting-a-non-photorealistic-shading-technique/
1716  * It is applied to all actors, including texts.
1717  * @param viewport
1718  */
1719  void
1720  enableEDLRendering(int viewport = 0);
1721 
1722  /** \brief Changes the visual representation for all actors to surface representation. */
1723  void
1724  setRepresentationToSurfaceForAllActors ();
1725 
1726  /** \brief Changes the visual representation for all actors to points representation. */
1727  void
1728  setRepresentationToPointsForAllActors ();
1729 
1730  /** \brief Changes the visual representation for all actors to wireframe representation. */
1731  void
1732  setRepresentationToWireframeForAllActors ();
1733 
1734  /** \brief Sets whether the 2D overlay text showing the framerate of the window is displayed or not.
1735  * \param[in] show_fps determines whether the fps text will be shown or not.
1736  */
1737  void
1738  setShowFPS (bool show_fps);
1739 
1740  /** Get the current rendering framerate.
1741  * \see setShowFPS */
1742  float
1743  getFPS () const;
1744 
1745  /** \brief Renders a virtual scene as seen from the camera viewpoint and returns the rendered point cloud.
1746  * ATT: This method will only render the scene if only on viewport exists. Otherwise, returns an empty
1747  * point cloud and exits immediately.
1748  * \param[in] xres is the size of the window (X) used to render the scene
1749  * \param[in] yres is the size of the window (Y) used to render the scene
1750  * \param[in] cloud is the rendered point cloud
1751  */
1752  void
1753  renderView (int xres, int yres, pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud);
1754 
1755  /** \brief The purpose of this method is to render a CAD model added to the visualizer from different viewpoints
1756  * in order to simulate partial views of model. The viewpoint locations are the vertices of a tessellated sphere
1757  * build from an icosaheadron. The tessellation parameter controls how many times the triangles of the original
1758  * icosahedron are divided to approximate the sphere and thus the number of partial view generated for a model,
1759  * with a tesselation_level of 0, 12 views are generated if use_vertices=true and 20 views if use_vertices=false
1760  *
1761  * \param[in] xres the size of the window (X) used to render the partial view of the object
1762  * \param[in] yres the size of the window (Y) used to render the partial view of the object
1763  * \param[in] cloud is a vector of pointcloud with XYZ information that represent the model as seen from the respective viewpoints.
1764  * \param[out] poses represent the transformation from object coordinates to camera coordinates for the respective viewpoint.
1765  * \param[out] enthropies are values between 0 and 1 representing which percentage of the model is seen from the respective viewpoint.
1766  * \param[in] tesselation_level represents the number of subdivisions applied to the triangles of original icosahedron.
1767  * \param[in] view_angle field of view of the virtual camera. Default: 45
1768  * \param[in] radius_sphere the tessellated sphere radius. Default: 1
1769  * \param[in] use_vertices if true, use the vertices of tessellated icosahedron (12,42,...) or if false, use the faces of tessellated
1770  * icosahedron (20,80,...). Default: true
1771  */
1772  void
1773  renderViewTesselatedSphere (
1774  int xres, int yres,
1775  pcl::PointCloud<pcl::PointXYZ>::CloudVectorType & cloud,
1776  std::vector<Eigen::Matrix4f,Eigen::aligned_allocator< Eigen::Matrix4f > > & poses, std::vector<float> & enthropies, int tesselation_level,
1777  float view_angle = 45, float radius_sphere = 1, bool use_vertices = true);
1778 
1779 
1780  /** \brief Initialize camera parameters with some default values. */
1781  void
1782  initCameraParameters ();
1783 
1784  /** \brief Search for camera parameters at the command line and set them internally.
1785  * \param[in] argc
1786  * \param[in] argv
1787  */
1788  bool
1789  getCameraParameters (int argc, char **argv);
1790 
1791  /** \brief Load camera parameters from a camera parameters file.
1792  * \param[in] file the name of the camera parameters file
1793  */
1794  bool
1795  loadCameraParameters (const std::string &file);
1796 
1797  /** \brief Checks whether the camera parameters were manually loaded.
1798  * \return True if valid "-cam" option is available in command line.
1799  * \sa cameraFileLoaded ()
1800  */
1801  bool
1802  cameraParamsSet () const;
1803 
1804  /** \brief Checks whether a camera file were automatically loaded.
1805  * \return True if a valid camera file is automatically loaded.
1806  * \note The camera file is saved by pressing "ctrl + s" during last run of the program
1807  * and restored automatically when the program runs this time.
1808  * \sa cameraParamsSet ()
1809  */
1810  bool
1811  cameraFileLoaded () const;
1812 
1813  /** \brief Get camera file for camera parameter saving/restoring.
1814  * \note This will be valid only when valid "-cam" option were available in command line
1815  * or a saved camera file were automatically loaded.
1816  * \sa cameraParamsSet (), cameraFileLoaded ()
1817  */
1818  std::string
1819  getCameraFile () const;
1820 
1821  /** \brief Update camera parameters and render. */
1822  PCL_DEPRECATED(1,15,"updateCamera will be removed, as it does nothing.")
1823  inline void
1824  updateCamera () {};
1825 
1826  /** \brief Reset camera parameters and render. */
1827  void
1828  resetCamera ();
1829 
1830  /** \brief Reset the camera direction from {0, 0, 0} to the center_{x, y, z} of a given dataset.
1831  * \param[in] id the point cloud object id (default: cloud)
1832  */
1833  void
1834  resetCameraViewpoint (const std::string &id = "cloud");
1835 
1836  /** \brief Set the camera pose given by position, viewpoint and up vector
1837  * \param[in] pos_x the x coordinate of the camera location
1838  * \param[in] pos_y the y coordinate of the camera location
1839  * \param[in] pos_z the z coordinate of the camera location
1840  * \param[in] view_x the x component of the view point of the camera
1841  * \param[in] view_y the y component of the view point of the camera
1842  * \param[in] view_z the z component of the view point of the camera
1843  * \param[in] up_x the x component of the view up direction of the camera
1844  * \param[in] up_y the y component of the view up direction of the camera
1845  * \param[in] up_z the z component of the view up direction of the camera
1846  * \param[in] viewport the viewport to modify camera of (0 modifies all cameras)
1847  */
1848  void
1849  setCameraPosition (double pos_x, double pos_y, double pos_z,
1850  double view_x, double view_y, double view_z,
1851  double up_x, double up_y, double up_z, int viewport = 0);
1852 
1853  /** \brief Set the camera location and viewup according to the given arguments
1854  * \param[in] pos_x the x coordinate of the camera location
1855  * \param[in] pos_y the y coordinate of the camera location
1856  * \param[in] pos_z the z coordinate of the camera location
1857  * \param[in] up_x the x component of the view up direction of the camera
1858  * \param[in] up_y the y component of the view up direction of the camera
1859  * \param[in] up_z the z component of the view up direction of the camera
1860  * \param[in] viewport the viewport to modify camera of (0 modifies all cameras)
1861  */
1862  void
1863  setCameraPosition (double pos_x, double pos_y, double pos_z,
1864  double up_x, double up_y, double up_z, int viewport = 0);
1865 
1866  /** \brief Set the camera parameters via an intrinsics and and extrinsics matrix
1867  * \note This assumes that the pixels are square and that the center of the image is at the center of the sensor.
1868  * \param[in] intrinsics the intrinsics that will be used to compute the VTK camera parameters
1869  * \param[in] extrinsics the extrinsics that will be used to compute the VTK camera parameters
1870  * \param[in] viewport the viewport to modify camera of (0 modifies all cameras)
1871  */
1872  void
1873  setCameraParameters (const Eigen::Matrix3f &intrinsics, const Eigen::Matrix4f &extrinsics, int viewport = 0);
1874 
1875  /** \brief Set the camera parameters by given a full camera data structure.
1876  * \param[in] camera camera structure containing all the camera parameters.
1877  * \param[in] viewport the viewport to modify camera of (0 modifies all cameras)
1878  */
1879  void
1880  setCameraParameters (const Camera &camera, int viewport = 0);
1881 
1882  /** \brief Set the camera clipping distances.
1883  * \param[in] near the near clipping distance (no objects closer than this to the camera will be drawn)
1884  * \param[in] far the far clipping distance (no objects further away than this to the camera will be drawn)
1885  * \param[in] viewport the viewport to modify camera of (0 modifies all cameras)
1886  */
1887  void
1888  setCameraClipDistances (double near, double far, int viewport = 0);
1889 
1890  /** \brief Set the camera vertical field of view.
1891  * \param[in] fovy vertical field of view in radians
1892  * \param[in] viewport the viewport to modify camera of (0 modifies all cameras)
1893  */
1894  void
1895  setCameraFieldOfView (double fovy, int viewport = 0);
1896 
1897  /** \brief Get the current camera parameters. */
1898  void
1899  getCameras (std::vector<Camera>& cameras);
1900 
1901 
1902  /** \brief Get the current viewing pose. */
1903  Eigen::Affine3f
1904  getViewerPose (int viewport = 0);
1905 
1906  /** \brief Save the current rendered image to disk, as a PNG screenshot.
1907  * \param[in] file the name of the PNG file
1908  */
1909  void
1910  saveScreenshot (const std::string &file);
1911 
1912  /** \brief Save the camera parameters to disk, as a .cam file.
1913  * \param[in] file the name of the .cam file
1914  */
1915  void
1916  saveCameraParameters (const std::string &file);
1917 
1918  /** \brief Get camera parameters of a given viewport (0 means default viewport). */
1919  void
1920  getCameraParameters (Camera &camera, int viewport = 0) const;
1921 
1922  /** \brief Return a pointer to the underlying VTK Render Window used. */
1923  vtkSmartPointer<vtkRenderWindow>
1924  getRenderWindow ()
1925  {
1926  return (win_);
1927  }
1928 
1929  /** \brief Return a pointer to the underlying VTK Renderer Collection. */
1930  vtkSmartPointer<vtkRendererCollection>
1931  getRendererCollection ()
1932  {
1933  return (rens_);
1934  }
1935 
1936  /** \brief Return a pointer to the CloudActorMap this visualizer uses. */
1937  CloudActorMapPtr
1938  getCloudActorMap ()
1939  {
1940  return (cloud_actor_map_);
1941  }
1942 
1943  /** \brief Return a pointer to the ShapeActorMap this visualizer uses. */
1944  ShapeActorMapPtr
1945  getShapeActorMap ()
1946  {
1947  return (shape_actor_map_);
1948  }
1949 
1950  /** \brief Set the position in screen coordinates.
1951  * \param[in] x where to move the window to (X)
1952  * \param[in] y where to move the window to (Y)
1953  */
1954  void
1955  setPosition (int x, int y);
1956 
1957  /** \brief Set the window size in screen coordinates.
1958  * \param[in] xw window size in horizontal (pixels)
1959  * \param[in] yw window size in vertical (pixels)
1960  */
1961  void
1962  setSize (int xw, int yw);
1963 
1964  /** \brief Use Vertex Buffer Objects renderers.
1965  * This is an optimization for the obsolete OpenGL backend. Modern OpenGL2 backend (VTK ≥ 6.3) uses vertex
1966  * buffer objects by default, transparently for the user.
1967  * \param[in] use_vbos set to true to use VBOs
1968  */
1969  void
1970  setUseVbos (bool use_vbos);
1971 
1972  /** \brief Set the ID of a cloud or shape to be used for LUT display
1973  * \param[in] id The id of the cloud/shape look up table to be displayed
1974  * The look up table is displayed by pressing 'u' in the PCLVisualizer */
1975  void
1976  setLookUpTableID (const std::string id);
1977 
1978  /** \brief Create the internal Interactor object. */
1979  void
1980  createInteractor ();
1981 
1982  /** \brief Set up our unique PCL interactor style for a given vtkRenderWindowInteractor object
1983  * attached to a given vtkRenderWindow
1984  * \param[in,out] iren the vtkRenderWindowInteractor object to set up
1985  * \param[in,out] win a vtkRenderWindow object that the interactor is attached to
1986  */
1987  void
1988  setupInteractor (vtkRenderWindowInteractor *iren,
1989  vtkRenderWindow *win);
1990 
1991  /** \brief Set up PCLVisualizer with custom interactor style for a given vtkRenderWindowInteractor object
1992  * attached to a given vtkRenderWindow
1993  * \param[in,out] iren the vtkRenderWindowInteractor object to set up
1994  * \param[in,out] win a vtkRenderWindow object that the interactor is attached to
1995  * \param[in,out] style a vtkInteractorStyle object
1996  */
1997  void
1998  setupInteractor (vtkRenderWindowInteractor *iren,
1999  vtkRenderWindow *win,
2000  vtkInteractorStyle *style);
2001 
2002  /** \brief Get a pointer to the current interactor style used. */
2003  inline vtkSmartPointer<PCLVisualizerInteractorStyle>
2004  getInteractorStyle ()
2005  {
2006  return (style_);
2007  }
2008  protected:
2009  /** \brief The render window interactor. */
2010  vtkSmartPointer<vtkRenderWindowInteractor> interactor_;
2011  private:
2012  /** \brief Internal function for renderer setup
2013  * \param[in] vtk renderer
2014  */
2015  void setupRenderer (vtkSmartPointer<vtkRenderer> ren);
2016 
2017  /** \brief Internal function for setting up FPS callback
2018  * \param[in] vtk renderer
2019  */
2020  void setupFPSCallback (const vtkSmartPointer<vtkRenderer>& ren);
2021 
2022  /** \brief Internal function for setting up render window
2023  * \param[in] name the window name
2024  */
2025  void setupRenderWindow (const std::string& name);
2026 
2027  /** \brief Internal function for setting up interactor style
2028  */
2029  void setupStyle ();
2030 
2031  /** \brief Internal function for setting the default render window size and position on screen
2032  */
2033  void setDefaultWindowSizeAndPos ();
2034 
2035  /** \brief Set up camera parameters.
2036  *
2037  * Parses command line arguments to find camera parameters (either explicit numbers or a path to a .cam file).
2038  * If not found, will generate a unique .cam file path (based on the rest of command line arguments) and try
2039  * to load that. If it is also not found, just set the defaults.
2040  */
2041  void setupCamera (int argc, char **argv);
2042 
2043  struct PCL_EXPORTS ExitMainLoopTimerCallback : public vtkCommand
2044  {
2045  static ExitMainLoopTimerCallback* New ()
2046  {
2047  return (new ExitMainLoopTimerCallback);
2048  }
2049  void
2050  Execute (vtkObject*, unsigned long event_id, void*) override;
2051 
2052  int right_timer_id;
2053  PCLVisualizer* pcl_visualizer;
2054  };
2055 
2056  struct PCL_EXPORTS ExitCallback : public vtkCommand
2057  {
2058  static ExitCallback* New ()
2059  {
2060  return (new ExitCallback);
2061  }
2062  void
2063  Execute (vtkObject*, unsigned long event_id, void*) override;
2064 
2065  PCLVisualizer* pcl_visualizer;
2066  };
2067 
2068  //////////////////////////////////////////////////////////////////////////////////////////////
2069  struct PCL_EXPORTS FPSCallback : public vtkCommand
2070  {
2071  static FPSCallback *New () { return (new FPSCallback); }
2072 
2073  FPSCallback () = default;
2074  FPSCallback (const FPSCallback& src) = default;
2075  FPSCallback& operator = (const FPSCallback& src) { actor = src.actor; pcl_visualizer = src.pcl_visualizer; decimated = src.decimated; last_fps = src.last_fps; return (*this); }
2076 
2077  void
2078  Execute (vtkObject*, unsigned long event_id, void*) override;
2079 
2080  vtkTextActor *actor{nullptr};
2081  PCLVisualizer* pcl_visualizer{nullptr};
2082  bool decimated{false};
2083  float last_fps{0.0f};
2084  };
2085 
2086  /** \brief The FPSCallback object for the current visualizer. */
2087  vtkSmartPointer<FPSCallback> update_fps_;
2088 
2089  /** \brief Set to false if the interaction loop is running. */
2090  bool stopped_{false};
2091 
2092  /** \brief Global timer ID. Used in destructor only. */
2093  int timer_id_{0};
2094 
2095  /** \brief Callback object enabling us to leave the main loop, when a timer fires. */
2096  vtkSmartPointer<ExitMainLoopTimerCallback> exit_main_loop_timer_callback_;
2097  vtkSmartPointer<ExitCallback> exit_callback_;
2098 
2099  /** \brief The collection of renderers used. */
2100  vtkSmartPointer<vtkRendererCollection> rens_;
2101 
2102  /** \brief The render window. */
2103  vtkSmartPointer<vtkRenderWindow> win_;
2104 
2105  /** \brief The render window interactor style. */
2106  vtkSmartPointer<PCLVisualizerInteractorStyle> style_;
2107 
2108  /** \brief Internal list with actor pointers and name IDs for point clouds. */
2109  CloudActorMapPtr cloud_actor_map_;
2110 
2111  /** \brief Internal list with actor pointers and name IDs for shapes. */
2112  ShapeActorMapPtr shape_actor_map_;
2113 
2114  /** \brief Internal list with actor pointers and viewpoint for coordinates. */
2115  CoordinateActorMapPtr coordinate_actor_map_;
2116 
2117  /** \brief Internal pointer to widget which contains a set of axes */
2118  vtkSmartPointer<vtkOrientationMarkerWidget> axes_widget_;
2119 
2120  /** \brief Boolean that holds whether or not the camera parameters were manually initialized */
2121  bool camera_set_;
2122 
2123  /** \brief Boolean that holds whether or not a camera file were automatically loaded */
2124  bool camera_file_loaded_;
2125 
2126  /** \brief Boolean that holds whether or not to use the vtkVertexBufferObjectMapper*/
2127  bool use_vbos_;
2128 
2129  /** \brief Internal method. Removes a vtk actor from the screen.
2130  * \param[in] actor a pointer to the vtk actor object
2131  * \param[in] viewport the view port where the actor should be removed from (default: all)
2132  */
2133  bool
2134  removeActorFromRenderer (const vtkSmartPointer<vtkLODActor> &actor,
2135  int viewport = 0);
2136 
2137  /** \brief Internal method. Removes a vtk actor from the screen.
2138  * \param[in] actor a pointer to the vtk actor object
2139  * \param[in] viewport the view port where the actor should be removed from (default: all)
2140  */
2141  bool
2142  removeActorFromRenderer (const vtkSmartPointer<vtkActor> &actor,
2143  int viewport = 0);
2144 
2145  /** \brief Internal method. Adds a vtk actor to screen.
2146  * \param[in] actor a pointer to the vtk actor object
2147  * \param[in] viewport port where the actor should be added to (default: 0/all)
2148  *
2149  * \note If viewport is set to 0, the actor will be added to all existing
2150  * renders. To select a specific viewport use an integer between 1 and N.
2151  */
2152  void
2153  addActorToRenderer (const vtkSmartPointer<vtkProp> &actor,
2154  int viewport = 0);
2155 
2156  /** \brief Internal method. Adds a vtk actor to screen.
2157  * \param[in] actor a pointer to the vtk actor object
2158  * \param[in] viewport the view port where the actor should be added to (default: all)
2159  */
2160  bool
2161  removeActorFromRenderer (const vtkSmartPointer<vtkProp> &actor,
2162  int viewport = 0);
2163 
2164  /** \brief Internal method. Creates a vtk actor from a vtk polydata object.
2165  * \param[in] data the vtk polydata object to create an actor for
2166  * \param[out] actor the resultant vtk actor object
2167  * \param[in] use_scalars set scalar properties to the mapper if it exists in the data. Default: true.
2168  */
2169  void
2170  createActorFromVTKDataSet (const vtkSmartPointer<vtkDataSet> &data,
2171  vtkSmartPointer<vtkActor> &actor,
2172  bool use_scalars = true) const;
2173 
2174  /** \brief Internal method. Creates a vtk actor from a vtk polydata object.
2175  * \param[in] data the vtk polydata object to create an actor for
2176  * \param[out] actor the resultant vtk actor object
2177  * \param[in] use_scalars set scalar properties to the mapper if it exists in the data. Default: true.
2178  */
2179  void
2180  createActorFromVTKDataSet (const vtkSmartPointer<vtkDataSet> &data,
2181  vtkSmartPointer<vtkLODActor> &actor,
2182  bool use_scalars = true) const;
2183 
2184  /** \brief Converts a PCL templated PointCloud object to a vtk polydata object.
2185  * \param[in] cloud the input PCL PointCloud dataset
2186  * \param[out] polydata the resultant polydata containing the cloud
2187  * \param[out] initcells a list of cell indices used for the conversion. This can be set once and then passed
2188  * around to speed up the conversion.
2189  */
2190  template <typename PointT> void
2191  convertPointCloudToVTKPolyData (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
2192  vtkSmartPointer<vtkPolyData> &polydata,
2193  vtkSmartPointer<vtkIdTypeArray> &initcells);
2194 
2195  /** \brief Converts a PCL templated PointCloud object to a vtk polydata object.
2196  * \param[in] geometry_handler the geometry handler object used to extract the XYZ data
2197  * \param[out] polydata the resultant polydata containing the cloud
2198  * \param[out] initcells a list of cell indices used for the conversion. This can be set once and then passed
2199  * around to speed up the conversion.
2200  */
2201  template <typename PointT> void
2202  convertPointCloudToVTKPolyData (const PointCloudGeometryHandler<PointT> &geometry_handler,
2203  vtkSmartPointer<vtkPolyData> &polydata,
2204  vtkSmartPointer<vtkIdTypeArray> &initcells);
2205 
2206  /** \brief Converts a PCL object to a vtk polydata object.
2207  * \param[in] geometry_handler the geometry handler object used to extract the XYZ data
2208  * \param[out] polydata the resultant polydata containing the cloud
2209  * \param[out] initcells a list of cell indices used for the conversion. This can be set once and then passed
2210  * around to speed up the conversion.
2211  */
2212  void
2213  convertPointCloudToVTKPolyData (const GeometryHandlerConstPtr &geometry_handler,
2214  vtkSmartPointer<vtkPolyData> &polydata,
2215  vtkSmartPointer<vtkIdTypeArray> &initcells);
2216 
2217  /** \brief Updates a set of cells (vtkIdTypeArray) if the number of points in a cloud changes
2218  * \param[out] cells the vtkIdTypeArray object (set of cells) to update
2219  * \param[out] initcells a previously saved set of cells. If the number of points in the current cloud is
2220  * higher than the number of cells in \a cells, and initcells contains enough data, then a copy from it
2221  * will be made instead of regenerating the entire array.
2222  * \param[in] nr_points the number of points in the new cloud. This dictates how many cells we need to
2223  * generate
2224  */
2225  void
2226  updateCells (vtkSmartPointer<vtkIdTypeArray> &cells,
2227  vtkSmartPointer<vtkIdTypeArray> &initcells,
2228  vtkIdType nr_points);
2229 
2230  /** \brief Internal function which converts the information present in the geometric
2231  * and color handlers into VTK PolyData+Scalars, constructs a vtkActor object, and adds
2232  * all the required information to the internal cloud_actor_map_ object.
2233  * \param[in] geometry_handler the geometric handler that contains the XYZ data
2234  * \param[in] color_handler the color handler that contains the "RGB" (scalar) data
2235  * \param[in] id the point cloud object id
2236  * \param[in] viewport the view port where the Point Cloud should be added
2237  * \param[in] sensor_origin the origin of the cloud data in global coordinates (defaults to 0,0,0)
2238  * \param[in] sensor_orientation the orientation of the cloud data in global coordinates (defaults to 1,0,0,0)
2239  */
2240  template <typename PointT> bool
2241  fromHandlersToScreen (const PointCloudGeometryHandler<PointT> &geometry_handler,
2242  const PointCloudColorHandler<PointT> &color_handler,
2243  const std::string &id,
2244  int viewport,
2245  const Eigen::Vector4f& sensor_origin = Eigen::Vector4f (0, 0, 0, 0),
2246  const Eigen::Quaternion<float>& sensor_orientation = Eigen::Quaternion<float> (1, 0, 0 ,0));
2247 
2248  /** \brief Internal function which converts the information present in the geometric
2249  * and color handlers into VTK PolyData+Scalars, constructs a vtkActor object, and adds
2250  * all the required information to the internal cloud_actor_map_ object.
2251  * \param[in] geometry_handler the geometric handler that contains the XYZ data
2252  * \param[in] color_handler the color handler that contains the "RGB" (scalar) data
2253  * \param[in] id the point cloud object id
2254  * \param[in] viewport the view port where the Point Cloud should be added
2255  * \param[in] sensor_origin the origin of the cloud data in global coordinates (defaults to 0,0,0)
2256  * \param[in] sensor_orientation the orientation of the cloud data in global coordinates (defaults to 1,0,0,0)
2257  */
2258  template <typename PointT> bool
2259  fromHandlersToScreen (const PointCloudGeometryHandler<PointT> &geometry_handler,
2260  const ColorHandlerConstPtr &color_handler,
2261  const std::string &id,
2262  int viewport,
2263  const Eigen::Vector4f& sensor_origin = Eigen::Vector4f (0, 0, 0, 0),
2264  const Eigen::Quaternion<float>& sensor_orientation = Eigen::Quaternion<float> (1, 0, 0 ,0));
2265 
2266  /** \brief Internal function which converts the information present in the geometric
2267  * and color handlers into VTK PolyData+Scalars, constructs a vtkActor object, and adds
2268  * all the required information to the internal cloud_actor_map_ object.
2269  * \param[in] geometry_handler the geometric handler that contains the XYZ data
2270  * \param[in] color_handler the color handler that contains the "RGB" (scalar) data
2271  * \param[in] id the point cloud object id
2272  * \param[in] viewport the view port where the Point Cloud should be added
2273  * \param[in] sensor_origin the origin of the cloud data in global coordinates (defaults to 0,0,0)
2274  * \param[in] sensor_orientation the orientation of the cloud data in global coordinates (defaults to 1,0,0,0)
2275  */
2276  bool
2277  fromHandlersToScreen (const GeometryHandlerConstPtr &geometry_handler,
2278  const ColorHandlerConstPtr &color_handler,
2279  const std::string &id,
2280  int viewport,
2281  const Eigen::Vector4f& sensor_origin = Eigen::Vector4f (0, 0, 0, 0),
2282  const Eigen::Quaternion<float>& sensor_orientation = Eigen::Quaternion<float> (1, 0, 0 ,0));
2283 
2284  /** \brief Internal function which converts the information present in the geometric
2285  * and color handlers into VTK PolyData+Scalars, constructs a vtkActor object, and adds
2286  * all the required information to the internal cloud_actor_map_ object.
2287  * \param[in] geometry_handler the geometric handler that contains the XYZ data
2288  * \param[in] color_handler the color handler that contains the "RGB" (scalar) data
2289  * \param[in] id the point cloud object id
2290  * \param[in] viewport the view port where the Point Cloud should be added
2291  * \param[in] sensor_origin the origin of the cloud data in global coordinates (defaults to 0,0,0)
2292  * \param[in] sensor_orientation the orientation of the cloud data in global coordinates (defaults to 1,0,0,0)
2293  */
2294  template <typename PointT> bool
2295  fromHandlersToScreen (const GeometryHandlerConstPtr &geometry_handler,
2296  const PointCloudColorHandler<PointT> &color_handler,
2297  const std::string &id,
2298  int viewport,
2299  const Eigen::Vector4f& sensor_origin = Eigen::Vector4f (0, 0, 0, 0),
2300  const Eigen::Quaternion<float>& sensor_orientation = Eigen::Quaternion<float> (1, 0, 0 ,0));
2301 
2302  /** \brief Allocate a new polydata smartpointer. Internal
2303  * \param[out] polydata the resultant poly data
2304  */
2305  void
2306  allocVtkPolyData (vtkSmartPointer<vtkAppendPolyData> &polydata);
2307 
2308  /** \brief Allocate a new polydata smartpointer. Internal
2309  * \param[out] polydata the resultant poly data
2310  */
2311  void
2312  allocVtkPolyData (vtkSmartPointer<vtkPolyData> &polydata);
2313 
2314  /** \brief Allocate a new unstructured grid smartpointer. Internal
2315  * \param[out] polydata the resultant poly data
2316  */
2317  void
2318  allocVtkUnstructuredGrid (vtkSmartPointer<vtkUnstructuredGrid> &polydata);
2319 
2320  /** \brief Transform the point cloud viewpoint to a transformation matrix
2321  * \param[in] origin the camera origin
2322  * \param[in] orientation the camera orientation
2323  * \param[out] transformation the camera transformation matrix
2324  */
2325  void
2326  getTransformationMatrix (const Eigen::Vector4f &origin,
2327  const Eigen::Quaternion<float> &orientation,
2328  Eigen::Matrix4f &transformation);
2329 
2330  /** \brief Fills a vtkTexture structure from pcl::TexMaterial.
2331  * \param[in] tex_mat texture material in PCL format
2332  * \param[out] vtk_tex texture material in VTK format
2333  * \return 0 on success and -1 else.
2334  * \note for now only image based textures are supported, image file must be in
2335  * tex_file attribute of \a tex_mat.
2336  */
2337  int
2338  textureFromTexMaterial (const pcl::TexMaterial& tex_mat,
2339  vtkTexture* vtk_tex) const;
2340 
2341  /** \brief Get camera file for camera parameter saving/restoring from command line.
2342  * Camera filename is calculated using sha1 value of all paths of input .pcd files
2343  * \return empty string if failed.
2344  */
2345  std::string
2346  getUniqueCameraFile (int argc, char **argv);
2347 
2348  //There's no reason these conversion functions shouldn't be public and static so others can use them.
2349  public:
2350  /** \brief Convert Eigen::Matrix4f to vtkMatrix4x4
2351  * \param[in] m the input Eigen matrix
2352  * \param[out] vtk_matrix the resultant VTK matrix
2353  */
2354  static void
2355  convertToVtkMatrix (const Eigen::Matrix4f &m,
2356  vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
2357 
2358  /** \brief Convert origin and orientation to vtkMatrix4x4
2359  * \param[in] origin the point cloud origin
2360  * \param[in] orientation the point cloud orientation
2361  * \param[out] vtk_matrix the resultant VTK 4x4 matrix
2362  */
2363  static void
2364  convertToVtkMatrix (const Eigen::Vector4f &origin,
2365  const Eigen::Quaternion<float> &orientation,
2366  vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
2367 
2368  /** \brief Convert vtkMatrix4x4 to an Eigen4f
2369  * \param[in] vtk_matrix the original VTK 4x4 matrix
2370  * \param[out] m the resultant Eigen 4x4 matrix
2371  */
2372  static void
2373  convertToEigenMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix,
2374  Eigen::Matrix4f &m);
2375 
2376  };
2377  }
2378 }
2379 
2380 #include <pcl/visualization/impl/pcl_visualizer.hpp>
pcl::PlanarPolygon
PlanarPolygon represents a planar (2D) polygon, potentially in a 3D space.
Definition: planar_polygon.h:52
pcl::PointCloud
PointCloud represents the base class in PCL for storing collections of 3D points.
Definition: point_cloud.h:173
pcl::PointCloud::CloudVectorType
std::vector< PointCloud< PointT >, Eigen::aligned_allocator< PointCloud< PointT > > > CloudVectorType
Definition: point_cloud.h:412
pcl::PointCloud::Ptr
shared_ptr< PointCloud< PointT > > Ptr
Definition: point_cloud.h:413
pcl::PointCloud::ConstPtr
shared_ptr< const PointCloud< PointT > > ConstPtr
Definition: point_cloud.h:414
pcl::visualization::AreaPickingEvent
/brief Class representing 3D area picking events.
Definition: area_picking_event.h:51
pcl::visualization::Camera
Camera class holds a set of camera parameters together with the window pos/size.
Definition: common.h:153
pcl::visualization::KeyboardEvent
/brief Class representing key hit/release events
Definition: keyboard_event.h:49
pcl::visualization::PCLVisualizer
PCL Visualizer main class.
Definition: pcl_visualizer.h:94
pcl::visualization::PCLVisualizer::close
void close()
Stop the interaction and close the visualization window.
pcl::visualization::PCLVisualizer::setPointCloudRenderingProperties
bool setPointCloudRenderingProperties(int property, double val1, double val2, double val3, const std::string &id="cloud", int viewport=0)
Set the rendering properties of a PointCloud (3x values - e.g., RGB)
pcl::visualization::PCLVisualizer::addPolygonMesh
bool addPolygonMesh(const pcl::PolygonMesh &polymesh, const std::string &id="polygon", int viewport=0)
Add a PolygonMesh object to screen.
pcl::visualization::PCLVisualizer::createViewPort
void createViewPort(double xmin, double ymin, double xmax, double ymax, int &viewport)
Create a new viewport from [xmin,ymin] -> [xmax,ymax].
pcl::visualization::PCLVisualizer::renderViewTesselatedSphere
void renderViewTesselatedSphere(int xres, int yres, pcl::PointCloud< pcl::PointXYZ >::CloudVectorType &cloud, std::vector< Eigen::Matrix4f, Eigen::aligned_allocator< Eigen::Matrix4f > > &poses, std::vector< float > &enthropies, int tesselation_level, float view_angle=45, float radius_sphere=1, bool use_vertices=true)
The purpose of this method is to render a CAD model added to the visualizer from different viewpoints...
pcl::visualization::PCLVisualizer::Ptr
shared_ptr< PCLVisualizer > Ptr
Definition: pcl_visualizer.h:96
pcl::visualization::PCLVisualizer::setPosition
void setPosition(int x, int y)
Set the position in screen coordinates.
pcl::visualization::PCLVisualizer::addPointCloud
bool addPointCloud(const pcl::PCLPointCloud2::ConstPtr &cloud, const GeometryHandlerConstPtr &geometry_handler, const Eigen::Vector4f &sensor_origin, const Eigen::Quaternion< float > &sensor_orientation, const std::string &id="cloud", int viewport=0)
Add a binary blob Point Cloud to screen.
pcl::visualization::PCLVisualizer::addPointCloud
bool addPointCloud(const pcl::PCLPointCloud2::ConstPtr &cloud, const GeometryHandlerConstPtr &geometry_handler, const ColorHandlerConstPtr &color_handler, const Eigen::Vector4f &sensor_origin, const Eigen::Quaternion< float > &sensor_orientation, const std::string &id="cloud", int viewport=0)
Add a binary blob Point Cloud to screen.
pcl::visualization::PCLVisualizer::removePointCloud
bool removePointCloud(const std::string &id="cloud", int viewport=0)
Removes a Point Cloud from screen, based on a given ID.
pcl::visualization::PCLVisualizer::updateCoordinateSystemPose
bool updateCoordinateSystemPose(const std::string &id, const Eigen::Affine3f &pose)
Set the pose of an existing coordinate system.
pcl::visualization::PCLVisualizer::registerAreaPickingCallback
boost::signals2::connection registerAreaPickingCallback(std::function< void(const pcl::visualization::AreaPickingEvent &)> cb)
Register a callback function for area picking events.
pcl::visualization::PCLVisualizer::addPointCloud
bool addPointCloud(const pcl::PointCloud< pcl::PointXYZRGBA >::ConstPtr &cloud, const std::string &id="cloud", int viewport=0)
Add a PointXYZRGBA Point Cloud to screen.
Definition: pcl_visualizer.h:899
pcl::visualization::PCLVisualizer::convertToVtkMatrix
static void convertToVtkMatrix(const Eigen::Matrix4f &m, vtkSmartPointer< vtkMatrix4x4 > &vtk_matrix)
Convert Eigen::Matrix4f to vtkMatrix4x4.
pcl::visualization::PCLVisualizer::addTextureMesh
bool addTextureMesh(const pcl::TextureMesh &polymesh, const std::string &id="texture", int viewport=0)
Add a TextureMesh object to screen.
pcl::visualization::PCLVisualizer::registerMouseCallback
boost::signals2::connection registerMouseCallback(void(T::*callback)(const pcl::visualization::MouseEvent &, void *), T &instance, void *cookie=nullptr)
Register a callback function for mouse events.
Definition: pcl_visualizer.h:224
pcl::visualization::PCLVisualizer::GeometryHandlerPtr
GeometryHandler::Ptr GeometryHandlerPtr
Definition: pcl_visualizer.h:100
pcl::visualization::PCLVisualizer::addCorrespondences
bool addCorrespondences(const typename pcl::PointCloud< PointT >::ConstPtr &source_points, const typename pcl::PointCloud< PointT >::ConstPtr &target_points, const pcl::Correspondences &correspondences, const std::string &id="correspondences", int viewport=0)
Add the specified correspondences to the display.
Definition: pcl_visualizer.h:1072
pcl::visualization::PCLVisualizer::setShapeRenderingProperties
bool setShapeRenderingProperties(int property, double val1, double val2, const std::string &id, int viewport=0)
Set the rendering properties of a shape (2x values - e.g., LUT minmax values)
pcl::visualization::PCLVisualizer::setCameraPosition
void setCameraPosition(double pos_x, double pos_y, double pos_z, double view_x, double view_y, double view_z, double up_x, double up_y, double up_z, int viewport=0)
Set the camera pose given by position, viewpoint and up vector.
pcl::visualization::PCLVisualizer::interactor_
vtkSmartPointer< vtkRenderWindowInteractor > interactor_
The render window interactor.
Definition: pcl_visualizer.h:2010
pcl::visualization::PCLVisualizer::registerPointPickingCallback
boost::signals2::connection registerPointPickingCallback(std::function< void(const pcl::visualization::PointPickingEvent &)> cb)
Register a callback function for point picking events.
pcl::visualization::PCLVisualizer::getCloudActorMap
CloudActorMapPtr getCloudActorMap()
Return a pointer to the CloudActorMap this visualizer uses.
Definition: pcl_visualizer.h:1938
pcl::visualization::PCLVisualizer::setupInteractor
void setupInteractor(vtkRenderWindowInteractor *iren, vtkRenderWindow *win, vtkInteractorStyle *style)
Set up PCLVisualizer with custom interactor style for a given vtkRenderWindowInteractor object attach...
pcl::visualization::PCLVisualizer::addPlane
bool addPlane(const pcl::ModelCoefficients &coefficients, const std::string &id="plane", int viewport=0)
Add a plane from a set of given model coefficients.
pcl::visualization::PCLVisualizer::removeCoordinateSystem
bool removeCoordinateSystem(const std::string &id="reference", int viewport=0)
Removes a previously added 3D axes (coordinate system)
pcl::visualization::PCLVisualizer::getRendererCollection
vtkSmartPointer< vtkRendererCollection > getRendererCollection()
Return a pointer to the underlying VTK Renderer Collection.
Definition: pcl_visualizer.h:1931
pcl::visualization::PCLVisualizer::updatePolygonMesh
bool updatePolygonMesh(const pcl::PolygonMesh &polymesh, const std::string &id="polygon")
Update a PolygonMesh object on screen.
pcl::visualization::PCLVisualizer::saveCameraParameters
void saveCameraParameters(const std::string &file)
Save the camera parameters to disk, as a .cam file.
pcl::visualization::PCLVisualizer::addCoordinateSystem
void addCoordinateSystem(double scale, const Eigen::Affine3f &t, const std::string &id="reference", int viewport=0)
Adds 3D axes describing a coordinate system to screen at x, y, z, Roll,Pitch,Yaw.
pcl::visualization::PCLVisualizer::updateColorHandlerIndex
bool updateColorHandlerIndex(const std::string &id, int index)
Update/set the color index of a rendered PointCloud based on its ID.
pcl::visualization::PCLVisualizer::setBackgroundColor
void setBackgroundColor(const double &r, const double &g, const double &b, int viewport=0)
Set the viewport's background color.
pcl::visualization::PCLVisualizer::addText
bool addText(const std::string &text, int xpos, int ypos, double r, double g, double b, const std::string &id="", int viewport=0)
Add a text to screen.
pcl::visualization::PCLVisualizer::~PCLVisualizer
virtual ~PCLVisualizer()
PCL Visualizer destructor.
pcl::visualization::PCLVisualizer::updateShapePose
bool updateShapePose(const std::string &id, const Eigen::Affine3f &pose)
Set the pose of an existing shape.
pcl::visualization::PCLVisualizer::setRepresentationToSurfaceForAllActors
void setRepresentationToSurfaceForAllActors()
Changes the visual representation for all actors to surface representation.
pcl::visualization::PCLVisualizer::setRepresentationToWireframeForAllActors
void setRepresentationToWireframeForAllActors()
Changes the visual representation for all actors to wireframe representation.
pcl::visualization::PCLVisualizer::removeAllCoordinateSystems
bool removeAllCoordinateSystems(int viewport=0)
Removes all existing 3D axes (coordinate systems)
pcl::visualization::PCLVisualizer::addPointCloud
bool addPointCloud(const pcl::PointCloud< pcl::PointXYZL >::ConstPtr &cloud, const std::string &id="cloud", int viewport=0)
Add a PointXYZL Point Cloud to screen.
Definition: pcl_visualizer.h:912
pcl::visualization::PCLVisualizer::addCoordinateSystem
void addCoordinateSystem(double scale=1.0, const std::string &id="reference", int viewport=0)
Adds 3D axes describing a coordinate system to screen at 0,0,0.
pcl::visualization::PCLVisualizer::registerKeyboardCallback
boost::signals2::connection registerKeyboardCallback(void(T::*callback)(const pcl::visualization::KeyboardEvent &, void *), T &instance, void *cookie=nullptr)
Register a callback function for keyboard events.
Definition: pcl_visualizer.h:194
pcl::visualization::PCLVisualizer::updatePointCloudPose
bool updatePointCloudPose(const std::string &id, const Eigen::Affine3f &pose)
Set the pose of an existing point cloud.
pcl::visualization::PCLVisualizer::setPointCloudSelected
bool setPointCloudSelected(const bool selected, const std::string &id="cloud")
Set whether the point cloud is selected or not.
pcl::visualization::PCLVisualizer::cameraParamsSet
bool cameraParamsSet() const
Checks whether the camera parameters were manually loaded.
pcl::visualization::PCLVisualizer::updateText
bool updateText(const std::string &text, int xpos, int ypos, const std::string &id="")
Update a text to screen.
pcl::visualization::PCLVisualizer::resetCameraViewpoint
void resetCameraViewpoint(const std::string &id="cloud")
Reset the camera direction from {0, 0, 0} to the center_{x, y, z} of a given dataset.
pcl::visualization::PCLVisualizer::addModelFromPolyData
bool addModelFromPolyData(vtkSmartPointer< vtkPolyData > polydata, const std::string &id="PolyData", int viewport=0)
Add a vtkPolydata as a mesh.
pcl::visualization::PCLVisualizer::updatePointCloud
bool updatePointCloud(const pcl::PointCloud< pcl::PointXYZ >::ConstPtr &cloud, const std::string &id="cloud")
Updates the XYZ data for an existing cloud object id on screen.
Definition: pcl_visualizer.h:925
pcl::visualization::PCLVisualizer::addText
bool addText(const std::string &text, int xpos, int ypos, const std::string &id="", int viewport=0)
Add a text to screen.
pcl::visualization::PCLVisualizer::registerAreaPickingCallback
boost::signals2::connection registerAreaPickingCallback(void(T::*callback)(const pcl::visualization::AreaPickingEvent &, void *), T &instance, void *cookie=nullptr)
Register a callback function for area picking events.
Definition: pcl_visualizer.h:278
pcl::visualization::PCLVisualizer::addLine
bool addLine(const pcl::ModelCoefficients &coefficients, const std::string &id="line", int viewport=0)
Add a line from a set of given model coefficients.
pcl::visualization::PCLVisualizer::addCircle
bool addCircle(const pcl::ModelCoefficients &coefficients, const std::string &id="circle", int viewport=0)
Add a circle from a set of given model coefficients.
pcl::visualization::PCLVisualizer::PCLVisualizer
PCLVisualizer(vtkSmartPointer< vtkRenderer > ren, vtkSmartPointer< vtkRenderWindow > wind, const std::string &name="", const bool create_interactor=true)
PCL Visualizer constructor.
pcl::visualization::PCLVisualizer::addModelFromPLYFile
bool addModelFromPLYFile(const std::string &filename, vtkSmartPointer< vtkTransform > transform, const std::string &id="PLYModel", int viewport=0)
Add a PLYmodel as a mesh and applies given transformation.
pcl::visualization::PCLVisualizer::cameraFileLoaded
bool cameraFileLoaded() const
Checks whether a camera file were automatically loaded.
pcl::visualization::PCLVisualizer::createViewPortCamera
void createViewPortCamera(const int viewport)
Create a new separate camera for the given viewport.
pcl::visualization::PCLVisualizer::getCameras
void getCameras(std::vector< Camera > &cameras)
Get the current camera parameters.
pcl::visualization::PCLVisualizer::getCameraFile
std::string getCameraFile() const
Get camera file for camera parameter saving/restoring.
pcl::visualization::PCLVisualizer::addCube
bool addCube(float x_min, float x_max, float y_min, float y_max, float z_min, float z_max, double r=1.0, double g=1.0, double b=1.0, const std::string &id="cube", int viewport=0)
Add a cube.
pcl::visualization::PCLVisualizer::addCube
bool addCube(const Eigen::Vector3f &translation, const Eigen::Quaternionf &rotation, double width, double height, double depth, const std::string &id="cube", int viewport=0)
Add a cube from a set of given model coefficients.
pcl::visualization::PCLVisualizer::getShapeActorMap
ShapeActorMapPtr getShapeActorMap()
Return a pointer to the ShapeActorMap this visualizer uses.
Definition: pcl_visualizer.h:1945
pcl::visualization::PCLVisualizer::GeometryHandlerConstPtr
GeometryHandler::ConstPtr GeometryHandlerConstPtr
Definition: pcl_visualizer.h:101
pcl::visualization::PCLVisualizer::setFullScreen
void setFullScreen(bool mode)
Enables/Disabled the underlying window mode to full screen.
pcl::visualization::PCLVisualizer::convertToVtkMatrix
static void convertToVtkMatrix(const Eigen::Vector4f &origin, const Eigen::Quaternion< float > &orientation, vtkSmartPointer< vtkMatrix4x4 > &vtk_matrix)
Convert origin and orientation to vtkMatrix4x4.
pcl::visualization::PCLVisualizer::wasStopped
bool wasStopped() const
Returns true when the user tried to close the window.
pcl::visualization::PCLVisualizer::setLookUpTableID
void setLookUpTableID(const std::string id)
Set the ID of a cloud or shape to be used for LUT display.
pcl::visualization::PCLVisualizer::addPlane
bool addPlane(const pcl::ModelCoefficients &coefficients, double x, double y, double z, const std::string &id="plane", int viewport=0)
pcl::visualization::PCLVisualizer::updatePointCloud
bool updatePointCloud(const pcl::PointCloud< pcl::PointXYZRGB >::ConstPtr &cloud, const std::string &id="cloud")
Updates the XYZRGB data for an existing cloud object id on screen.
Definition: pcl_visualizer.h:937
pcl::visualization::PCLVisualizer::setCameraFieldOfView
void setCameraFieldOfView(double fovy, int viewport=0)
Set the camera vertical field of view.
pcl::visualization::PCLVisualizer::removeOrientationMarkerWidgetAxes
void removeOrientationMarkerWidgetAxes()
Disables the Orientatation Marker Widget so it is removed from the renderer.
pcl::visualization::PCLVisualizer::renderView
void renderView(int xres, int yres, pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud)
Renders a virtual scene as seen from the camera viewpoint and returns the rendered point cloud.
pcl::visualization::PCLVisualizer::addCone
bool addCone(const pcl::ModelCoefficients &coefficients, const std::string &id="cone", int viewport=0)
Add a cone from a set of given model coefficients.
pcl::visualization::PCLVisualizer::getGeometryHandlerIndex
int getGeometryHandlerIndex(const std::string &id)
Get the geometry handler index of a rendered PointCloud based on its ID.
pcl::visualization::PCLVisualizer::enableEDLRendering
void enableEDLRendering(int viewport=0)
Eye-Dome Lighting makes dark areas to improve depth perception See https://www.kitware....
pcl::visualization::PCLVisualizer::spinOnce
void spinOnce(int time=1, bool force_redraw=false)
Spin once method.
pcl::visualization::PCLVisualizer::PCLVisualizer
PCLVisualizer(const std::string &name="", const bool create_interactor=true)
PCL Visualizer constructor.
pcl::visualization::PCLVisualizer::setSize
void setSize(int xw, int yw)
Set the window size in screen coordinates.
pcl::visualization::PCLVisualizer::updateText
bool updateText(const std::string &text, int xpos, int ypos, int fontsize, double r, double g, double b, const std::string &id="")
Update a text to screen.
pcl::visualization::PCLVisualizer::removeAllPointClouds
bool removeAllPointClouds(int viewport=0)
Remove all point cloud data on screen from the given viewport.
pcl::visualization::PCLVisualizer::ColorHandlerConstPtr
ColorHandler::ConstPtr ColorHandlerConstPtr
Definition: pcl_visualizer.h:105
pcl::visualization::PCLVisualizer::addPointCloud
bool addPointCloud(const pcl::PCLPointCloud2::ConstPtr &cloud, const ColorHandlerConstPtr &color_handler, const Eigen::Vector4f &sensor_origin, const Eigen::Quaternion< float > &sensor_orientation, const std::string &id="cloud", int viewport=0)
Add a binary blob Point Cloud to screen.
pcl::visualization::PCLVisualizer::addModelFromPLYFile
bool addModelFromPLYFile(const std::string &filename, const std::string &id="PLYModel", int viewport=0)
Add a PLYmodel as a mesh.
pcl::visualization::PCLVisualizer::setCameraParameters
void setCameraParameters(const Camera &camera, int viewport=0)
Set the camera parameters by given a full camera data structure.
pcl::visualization::PCLVisualizer::registerPointPickingCallback
boost::signals2::connection registerPointPickingCallback(void(T::*callback)(const pcl::visualization::PointPickingEvent &, void *), T &instance, void *cookie=nullptr)
Register a callback function for point picking events.
Definition: pcl_visualizer.h:251
pcl::visualization::PCLVisualizer::addText
bool addText(const std::string &text, int xpos, int ypos, int fontsize, double r, double g, double b, const std::string &id="", int viewport=0)
Add a text to screen.
pcl::visualization::PCLVisualizer::setUseVbos
void setUseVbos(bool use_vbos)
Use Vertex Buffer Objects renderers.
pcl::visualization::PCLVisualizer::loadCameraParameters
bool loadCameraParameters(const std::string &file)
Load camera parameters from a camera parameters file.
pcl::visualization::PCLVisualizer::setShowFPS
void setShowFPS(bool show_fps)
Sets whether the 2D overlay text showing the framerate of the window is displayed or not.
pcl::visualization::PCLVisualizer::getCameraParameters
bool getCameraParameters(int argc, char **argv)
Search for camera parameters at the command line and set them internally.
pcl::visualization::PCLVisualizer::getColorHandlerIndex
int getColorHandlerIndex(const std::string &id)
Get the color handler index of a rendered PointCloud based on its ID.
pcl::visualization::PCLVisualizer::setupInteractor
void setupInteractor(vtkRenderWindowInteractor *iren, vtkRenderWindow *win)
Set up our unique PCL interactor style for a given vtkRenderWindowInteractor object attached to a giv...
pcl::visualization::PCLVisualizer::setCameraClipDistances
void setCameraClipDistances(double near, double far, int viewport=0)
Set the camera clipping distances.
pcl::visualization::PCLVisualizer::createInteractor
void createInteractor()
Create the internal Interactor object.
pcl::visualization::PCLVisualizer::addCube
bool addCube(const pcl::ModelCoefficients &coefficients, const std::string &id="cube", int viewport=0)
Add a cube from a set of given model coefficients.
pcl::visualization::PCLVisualizer::removeAllShapes
bool removeAllShapes(int viewport=0)
Remove all 3D shape data on screen from the given viewport.
pcl::visualization::PCLVisualizer::getFPS
float getFPS() const
Get the current rendering framerate.
pcl::visualization::PCLVisualizer::addPointCloudPrincipalCurvatures
bool addPointCloudPrincipalCurvatures(const typename pcl::PointCloud< PointNT >::ConstPtr &cloud, const typename pcl::PointCloud< pcl::PrincipalCurvatures >::ConstPtr &pcs, int level=100, float scale=1.0f, const std::string &id="cloud", int viewport=0)
Add the estimated principal curvatures of a Point Cloud to screen.
pcl::visualization::PCLVisualizer::registerKeyboardCallback
boost::signals2::connection registerKeyboardCallback(void(*callback)(const pcl::visualization::KeyboardEvent &, void *), void *cookie=nullptr)
Register a callback function for keyboard events.
Definition: pcl_visualizer.h:182
pcl::visualization::PCLVisualizer::setShapeRenderingProperties
bool setShapeRenderingProperties(int property, double value, const std::string &id, int viewport=0)
Set the rendering properties of a shape.
pcl::visualization::PCLVisualizer::initCameraParameters
void initCameraParameters()
Initialize camera parameters with some default values.
pcl::visualization::PCLVisualizer::getRenderWindow
vtkSmartPointer< vtkRenderWindow > getRenderWindow()
Return a pointer to the underlying VTK Render Window used.
Definition: pcl_visualizer.h:1924
pcl::visualization::PCLVisualizer::PCLVisualizer
PCLVisualizer(int &argc, char **argv, const std::string &name="", PCLVisualizerInteractorStyle *style=PCLVisualizerInteractorStyle::New(), const bool create_interactor=true)
PCL Visualizer constructor.
pcl::visualization::PCLVisualizer::setCameraPosition
void setCameraPosition(double pos_x, double pos_y, double pos_z, double up_x, double up_y, double up_z, int viewport=0)
Set the camera location and viewup according to the given arguments.
pcl::visualization::PCLVisualizer::resetCamera
void resetCamera()
Reset camera parameters and render.
pcl::visualization::PCLVisualizer::registerMouseCallback
boost::signals2::connection registerMouseCallback(void(*callback)(const pcl::visualization::MouseEvent &, void *), void *cookie=nullptr)
Register a callback function for mouse events.
Definition: pcl_visualizer.h:212
pcl::visualization::PCLVisualizer::addCoordinateSystem
void addCoordinateSystem(double scale, float x, float y, float z, const std::string &id="reference", int viewport=0)
Adds 3D axes describing a coordinate system to screen at x, y, z.
pcl::visualization::PCLVisualizer::setShapeRenderingProperties
bool setShapeRenderingProperties(int property, double val1, double val2, double val3, const std::string &id, int viewport=0)
Set the rendering properties of a shape (3x values - e.g., RGB)
pcl::visualization::PCLVisualizer::removePolygonMesh
bool removePolygonMesh(const std::string &id="polygon", int viewport=0)
Removes a PolygonMesh from screen, based on a given ID.
Definition: pcl_visualizer.h:385
pcl::visualization::PCLVisualizer::addPointCloud
bool addPointCloud(const pcl::PointCloud< pcl::PointXYZRGB >::ConstPtr &cloud, const std::string &id="cloud", int viewport=0)
Add a PointXYZRGB Point Cloud to screen.
Definition: pcl_visualizer.h:886
pcl::visualization::PCLVisualizer::updateText
bool updateText(const std::string &text, int xpos, int ypos, double r, double g, double b, const std::string &id="")
Update a text to screen.
pcl::visualization::PCLVisualizer::contains
bool contains(const std::string &id) const
Check if the cloud, shape, or coordinate with the given id was already added to this visualizer.
Definition: pcl_visualizer.h:595
pcl::visualization::PCLVisualizer::setWindowName
void setWindowName(const std::string &name)
Set the visualizer window name.
pcl::visualization::PCLVisualizer::setWindowBorders
void setWindowBorders(bool mode)
Enables or disable the underlying window borders.
pcl::visualization::PCLVisualizer::registerPointPickingCallback
boost::signals2::connection registerPointPickingCallback(void(*callback)(const pcl::visualization::PointPickingEvent &, void *), void *cookie=nullptr)
Register a callback function for point picking events.
pcl::visualization::PCLVisualizer::updatePointCloud
bool updatePointCloud(const pcl::PointCloud< pcl::PointXYZL >::ConstPtr &cloud, const std::string &id="cloud")
Updates the XYZL data for an existing cloud object id on screen.
Definition: pcl_visualizer.h:963
pcl::visualization::PCLVisualizer::removeText3D
bool removeText3D(const std::string &id="cloud", int viewport=0)
Removes an added 3D text from the scene, based on a given ID.
pcl::visualization::PCLVisualizer::registerAreaPickingCallback
boost::signals2::connection registerAreaPickingCallback(void(*callback)(const pcl::visualization::AreaPickingEvent &, void *), void *cookie=nullptr)
Register a callback function for area picking events.
pcl::visualization::PCLVisualizer::setPointCloudRenderingProperties
bool setPointCloudRenderingProperties(int property, double value, const std::string &id="cloud", int viewport=0)
Set the rendering properties of a PointCloud.
pcl::visualization::PCLVisualizer::getPointCloudRenderingProperties
bool getPointCloudRenderingProperties(RenderingProperties property, double &val1, double &val2, double &val3, const std::string &id="cloud")
Get the rendering properties of a PointCloud.
pcl::visualization::PCLVisualizer::saveScreenshot
void saveScreenshot(const std::string &file)
Save the current rendered image to disk, as a PNG screenshot.
pcl::visualization::PCLVisualizer::PCLVisualizer
PCLVisualizer(int &argc, char **argv, vtkSmartPointer< vtkRenderer > ren, vtkSmartPointer< vtkRenderWindow > wind, const std::string &name="", PCLVisualizerInteractorStyle *style=PCLVisualizerInteractorStyle::New(), const bool create_interactor=true)
PCL Visualizer constructor.
pcl::visualization::PCLVisualizer::convertToEigenMatrix
static void convertToEigenMatrix(const vtkSmartPointer< vtkMatrix4x4 > &vtk_matrix, Eigen::Matrix4f &m)
Convert vtkMatrix4x4 to an Eigen4f.
pcl::visualization::PCLVisualizer::addPolylineFromPolygonMesh
bool addPolylineFromPolygonMesh(const pcl::PolygonMesh &polymesh, const std::string &id="polyline", int viewport=0)
Add a Polygonline from a polygonMesh object to screen.
pcl::visualization::PCLVisualizer::getPointCloudRenderingProperties
bool getPointCloudRenderingProperties(int property, double &value, const std::string &id="cloud")
Get the rendering properties of a PointCloud.
pcl::visualization::PCLVisualizer::updatePointCloud
bool updatePointCloud(const pcl::PointCloud< pcl::PointXYZRGBA >::ConstPtr &cloud, const std::string &id="cloud")
Updates the XYZRGBA data for an existing cloud object id on screen.
Definition: pcl_visualizer.h:950
pcl::visualization::PCLVisualizer::removeShape
bool removeShape(const std::string &id="cloud", int viewport=0)
Removes an added shape from screen (line, polygon, etc.), based on a given ID.
pcl::visualization::PCLVisualizer::registerMouseCallback
boost::signals2::connection registerMouseCallback(std::function< void(const pcl::visualization::MouseEvent &)> cb)
Register a callback function for mouse events.
pcl::visualization::PCLVisualizer::resetStoppedFlag
void resetStoppedFlag()
Set the stopped flag back to false.
pcl::visualization::PCLVisualizer::ConstPtr
shared_ptr< const PCLVisualizer > ConstPtr
Definition: pcl_visualizer.h:97
pcl::visualization::PCLVisualizer::getCameraParameters
void getCameraParameters(Camera &camera, int viewport=0) const
Get camera parameters of a given viewport (0 means default viewport).
pcl::visualization::PCLVisualizer::registerKeyboardCallback
boost::signals2::connection registerKeyboardCallback(std::function< void(const pcl::visualization::KeyboardEvent &)> cb)
Register a callback std::function for keyboard events.
pcl::visualization::PCLVisualizer::getViewerPose
Eigen::Affine3f getViewerPose(int viewport=0)
Get the current viewing pose.
pcl::visualization::PCLVisualizer::addPointCloud
bool addPointCloud(const pcl::PointCloud< pcl::PointXYZ >::ConstPtr &cloud, const std::string &id="cloud", int viewport=0)
Add a PointXYZ Point Cloud to screen.
Definition: pcl_visualizer.h:873
pcl::visualization::PCLVisualizer::addOrientationMarkerWidgetAxes
void addOrientationMarkerWidgetAxes(vtkRenderWindowInteractor *interactor)
Adds a widget which shows an interactive axes display for orientation.
pcl::visualization::PCLVisualizer::addEllipsoid
bool addEllipsoid(const Eigen::Isometry3d &transform, double radius_x, double radius_y, double radius_z, const std::string &id="ellipsoid", int viewport=0)
Add an ellipsoid from the given parameters.
pcl::visualization::PCLVisualizer::addCylinder
bool addCylinder(const pcl::ModelCoefficients &coefficients, const std::string &id="cylinder", int viewport=0)
Add a cylinder from a set of given model coefficients.
pcl::visualization::PCLVisualizer::setRepresentationToPointsForAllActors
void setRepresentationToPointsForAllActors()
Changes the visual representation for all actors to points representation.
pcl::visualization::PCLVisualizer::setPointCloudRenderingProperties
bool setPointCloudRenderingProperties(int property, double val1, double val2, const std::string &id="cloud", int viewport=0)
Set the rendering properties of a PointCloud (2x values - e.g., LUT minmax values)
pcl::visualization::PCLVisualizer::addLine
bool addLine(const pcl::ModelCoefficients &coefficients, const char *id="line", int viewport=0)
Add a line from a set of given model coefficients.
Definition: pcl_visualizer.h:1587
pcl::visualization::PCLVisualizer::updateCorrespondences
bool updateCorrespondences(const typename pcl::PointCloud< PointT >::ConstPtr &source_points, const typename pcl::PointCloud< PointT >::ConstPtr &target_points, const pcl::Correspondences &correspondences, const std::string &id="correspondences", int viewport=0)
Update the specified correspondences to the display.
Definition: pcl_visualizer.h:1108
pcl::visualization::PCLVisualizer::removeCorrespondences
void removeCorrespondences(const std::string &id="correspondences", int viewport=0)
Remove the specified correspondences from the display.
pcl::visualization::PCLVisualizer::addModelFromPolyData
bool addModelFromPolyData(vtkSmartPointer< vtkPolyData > polydata, vtkSmartPointer< vtkTransform > transform, const std::string &id="PolyData", int viewport=0)
Add a vtkPolydata as a mesh.
pcl::visualization::PCLVisualizer::setCameraParameters
void setCameraParameters(const Eigen::Matrix3f &intrinsics, const Eigen::Matrix4f &extrinsics, int viewport=0)
Set the camera parameters via an intrinsics and and extrinsics matrix.
pcl::visualization::PCLVisualizer::getInteractorStyle
vtkSmartPointer< PCLVisualizerInteractorStyle > getInteractorStyle()
Get a pointer to the current interactor style used.
Definition: pcl_visualizer.h:2004
pcl::visualization::PCLVisualizer::addSphere
bool addSphere(const pcl::ModelCoefficients &coefficients, const std::string &id="sphere", int viewport=0)
Add a sphere from a set of given model coefficients.
pcl::visualization::PCLVisualizerInteractorStyle
PCLVisualizerInteractorStyle defines an unique, custom VTK based interactory style for PCL Visualizer...
Definition: interactor_style.h:108
pcl::visualization::PCLVisualizerInteractorStyle::New
static PCLVisualizerInteractorStyle * New()
pcl::visualization::PointCloudColorHandler< pcl::PCLPointCloud2 >::ConstPtr
shared_ptr< const PointCloudColorHandler< PointCloud > > ConstPtr
Definition: point_cloud_color_handlers.h:533
pcl::visualization::PointCloudColorHandler
Base Handler class for PointCloud colors.
Definition: point_cloud_color_handlers.h:66
pcl::visualization::PointCloudGeometryHandler< pcl::PCLPointCloud2 >::ConstPtr
shared_ptr< const PointCloudGeometryHandler< PointCloud > > ConstPtr
Definition: point_cloud_geometry_handlers.h:329
pcl::visualization::PointCloudGeometryHandler
Base handler class for PointCloud geometry.
Definition: point_cloud_geometry_handlers.h:63
pcl::visualization::PointPickingEvent
/brief Class representing 3D point picking events.
Definition: point_picking_event.h:94
pcl::visualization::details::fillCells
PCL_EXPORTS vtkIdType fillCells(std::vector< int > &lookup, const std::vector< pcl::Vertices > &vertices, vtkSmartPointer< vtkCellArray > cell_array, int max_size_of_polygon)
pcl::visualization::RenderingProperties
RenderingProperties
Set of rendering properties.
Definition: common.h:102
pcl::visualization::CloudActorMapPtr
shared_ptr< CloudActorMap > CloudActorMapPtr
Definition: actor_map.h:97
pcl::visualization::ShapeActorMapPtr
shared_ptr< ShapeActorMap > ShapeActorMapPtr
Definition: actor_map.h:100
pcl::visualization::CoordinateActorMapPtr
shared_ptr< CoordinateActorMap > CoordinateActorMapPtr
Definition: actor_map.h:103
pcl::visualization::allocVtkUnstructuredGrid
PCL_EXPORTS void allocVtkUnstructuredGrid(vtkSmartPointer< vtkUnstructuredGrid > &polydata)
Allocate a new unstructured grid smartpointer.
pcl::Correspondences
std::vector< pcl::Correspondence, Eigen::aligned_allocator< pcl::Correspondence > > Correspondences
Definition: correspondence.h:89
PCL_EXPORTS
#define PCL_EXPORTS
Definition: pcl_macros.h:323
PCL_DEPRECATED
#define PCL_DEPRECATED(Major, Minor, Message)
macro for compatibility across compilers and help remove old deprecated items for the Major....
Definition: pcl_macros.h:156
pcl::PCLPointCloud2::ConstPtr
shared_ptr< const ::pcl::PCLPointCloud2 > ConstPtr
Definition: PCLPointCloud2.h:36
pcl::PointXYZRGB
A point structure representing Euclidean xyz coordinates, and the RGB color.
Definition: point_types.hpp:623