Point Cloud Library (PCL) 1.14.0
Loading...
Searching...
No Matches
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
60class vtkPolyData;
61class vtkTextActor;
62class vtkRenderWindow;
63class vtkAppendPolyData;
64class vtkRenderWindow;
65class vtkTransform;
66class vtkInteractorStyle;
67class vtkLODActor;
68class vtkProp;
69class vtkActor;
70class vtkDataSet;
71class vtkUnstructuredGrid;
72class vtkCellArray;
73
74namespace 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
102
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 initilalized.
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
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
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
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
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
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
638 const typename pcl::PointCloud<PointNT>::ConstPtr &cloud,
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,
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
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
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
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
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
887 const std::string &id = "cloud", int viewport = 0)
888 {
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
900 const std::string &id = "cloud", int viewport = 0)
901 {
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
913 const std::string &id = "cloud", int viewport = 0)
914 {
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
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
938 const std::string &id = "cloud")
939 {
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
951 const std::string &id = "cloud")
952 {
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
964 const std::string &id = "cloud")
965 {
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
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
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
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
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
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
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
1256
1257 /** \brief Stop the interaction and close the visualization window. */
1258 void
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
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
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,
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
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
1725
1726 /** \brief Changes the visual representation for all actors to points representation. */
1727 void
1729
1730 /** \brief Changes the visual representation for all actors to wireframe representation. */
1731 void
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
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
1774 int xres, int yres,
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
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
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
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
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
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. */
1925 {
1926 return (win_);
1927 }
1928
1929 /** \brief Return a pointer to the underlying VTK Renderer Collection. */
1932 {
1933 return (rens_);
1934 }
1935
1936 /** \brief Return a pointer to the CloudActorMap this visualizer uses. */
1939 {
1940 return (cloud_actor_map_);
1941 }
1942
1943 /** \brief Return a pointer to the ShapeActorMap this visualizer uses. */
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
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. */
2005 {
2006 return (style_);
2007 }
2008 protected:
2009 /** \brief The render window 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. */
2101
2102 /** \brief The render window. */
2104
2105 /** \brief The render window interactor 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 */
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,
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,
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,
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,
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,
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,
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
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
2374 Eigen::Matrix4f &m);
2375
2376 };
2377 }
2378}
2379
2380#include <pcl/visualization/impl/pcl_visualizer.hpp>
PlanarPolygon represents a planar (2D) polygon, potentially in a 3D space.
PointCloud represents the base class in PCL for storing collections of 3D points.
std::vector< PointCloud< PointT >, Eigen::aligned_allocator< PointCloud< PointT > > > CloudVectorType
shared_ptr< PointCloud< PointT > > Ptr
shared_ptr< const PointCloud< PointT > > ConstPtr
/brief Class representing 3D area picking events.
Camera class holds a set of camera parameters together with the window pos/size.
Definition common.h:153
/brief Class representing key hit/release events
PCL Visualizer main class.
void close()
Stop the interaction and close the visualization window.
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)
bool addPolygonMesh(const pcl::PolygonMesh &polymesh, const std::string &id="polygon", int viewport=0)
Add a PolygonMesh object to screen.
void createViewPort(double xmin, double ymin, double xmax, double ymax, int &viewport)
Create a new viewport from [xmin,ymin] -> [xmax,ymax].
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...
shared_ptr< PCLVisualizer > Ptr
void setPosition(int x, int y)
Set the position in screen coordinates.
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.
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.
bool removePointCloud(const std::string &id="cloud", int viewport=0)
Removes a Point Cloud from screen, based on a given ID.
bool updateCoordinateSystemPose(const std::string &id, const Eigen::Affine3f &pose)
Set the pose of an existing coordinate system.
boost::signals2::connection registerAreaPickingCallback(std::function< void(const pcl::visualization::AreaPickingEvent &)> cb)
Register a callback function for area picking events.
bool addPointCloud(const pcl::PointCloud< pcl::PointXYZRGBA >::ConstPtr &cloud, const std::string &id="cloud", int viewport=0)
Add a PointXYZRGBA Point Cloud to screen.
static void convertToVtkMatrix(const Eigen::Matrix4f &m, vtkSmartPointer< vtkMatrix4x4 > &vtk_matrix)
Convert Eigen::Matrix4f to vtkMatrix4x4.
bool addTextureMesh(const pcl::TextureMesh &polymesh, const std::string &id="texture", int viewport=0)
Add a TextureMesh object to screen.
boost::signals2::connection registerMouseCallback(void(T::*callback)(const pcl::visualization::MouseEvent &, void *), T &instance, void *cookie=nullptr)
Register a callback function for mouse events.
GeometryHandler::Ptr GeometryHandlerPtr
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.
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)
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.
vtkSmartPointer< vtkRenderWindowInteractor > interactor_
The render window interactor.
boost::signals2::connection registerPointPickingCallback(std::function< void(const pcl::visualization::PointPickingEvent &)> cb)
Register a callback function for point picking events.
CloudActorMapPtr getCloudActorMap()
Return a pointer to the CloudActorMap this visualizer uses.
void setupInteractor(vtkRenderWindowInteractor *iren, vtkRenderWindow *win, vtkInteractorStyle *style)
Set up PCLVisualizer with custom interactor style for a given vtkRenderWindowInteractor object attach...
bool addPlane(const pcl::ModelCoefficients &coefficients, const std::string &id="plane", int viewport=0)
Add a plane from a set of given model coefficients.
bool removeCoordinateSystem(const std::string &id="reference", int viewport=0)
Removes a previously added 3D axes (coordinate system)
bool updatePolygonMesh(const pcl::PolygonMesh &polymesh, const std::string &id="polygon")
Update a PolygonMesh object on screen.
void saveCameraParameters(const std::string &file)
Save the camera parameters to disk, as a .cam file.
vtkSmartPointer< vtkRendererCollection > getRendererCollection()
Return a pointer to the underlying VTK Renderer Collection.
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.
bool updateColorHandlerIndex(const std::string &id, int index)
Update/set the color index of a rendered PointCloud based on its ID.
void setBackgroundColor(const double &r, const double &g, const double &b, int viewport=0)
Set the viewport's background color.
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.
virtual ~PCLVisualizer()
PCL Visualizer destructor.
bool updateShapePose(const std::string &id, const Eigen::Affine3f &pose)
Set the pose of an existing shape.
void setRepresentationToSurfaceForAllActors()
Changes the visual representation for all actors to surface representation.
void setRepresentationToWireframeForAllActors()
Changes the visual representation for all actors to wireframe representation.
bool removeAllCoordinateSystems(int viewport=0)
Removes all existing 3D axes (coordinate systems)
bool addPointCloud(const pcl::PointCloud< pcl::PointXYZL >::ConstPtr &cloud, const std::string &id="cloud", int viewport=0)
Add a PointXYZL Point Cloud to screen.
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.
boost::signals2::connection registerKeyboardCallback(void(T::*callback)(const pcl::visualization::KeyboardEvent &, void *), T &instance, void *cookie=nullptr)
Register a callback function for keyboard events.
bool updatePointCloudPose(const std::string &id, const Eigen::Affine3f &pose)
Set the pose of an existing point cloud.
bool setPointCloudSelected(const bool selected, const std::string &id="cloud")
Set whether the point cloud is selected or not.
bool cameraParamsSet() const
Checks whether the camera parameters were manually loaded.
bool updateText(const std::string &text, int xpos, int ypos, const std::string &id="")
Update a text to screen.
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.
bool addModelFromPolyData(vtkSmartPointer< vtkPolyData > polydata, const std::string &id="PolyData", int viewport=0)
Add a vtkPolydata as a mesh.
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.
bool addText(const std::string &text, int xpos, int ypos, const std::string &id="", int viewport=0)
Add a text to screen.
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.
bool addLine(const pcl::ModelCoefficients &coefficients, const std::string &id="line", int viewport=0)
Add a line from a set of given model coefficients.
bool addCircle(const pcl::ModelCoefficients &coefficients, const std::string &id="circle", int viewport=0)
Add a circle from a set of given model coefficients.
PCLVisualizer(vtkSmartPointer< vtkRenderer > ren, vtkSmartPointer< vtkRenderWindow > wind, const std::string &name="", const bool create_interactor=true)
PCL Visualizer constructor.
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.
bool cameraFileLoaded() const
Checks whether a camera file were automatically loaded.
void createViewPortCamera(const int viewport)
Create a new separate camera for the given viewport.
void getCameras(std::vector< Camera > &cameras)
Get the current camera parameters.
std::string getCameraFile() const
Get camera file for camera parameter saving/restoring.
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.
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.
ShapeActorMapPtr getShapeActorMap()
Return a pointer to the ShapeActorMap this visualizer uses.
GeometryHandler::ConstPtr GeometryHandlerConstPtr
void setFullScreen(bool mode)
Enables/Disabled the underlying window mode to full screen.
static void convertToVtkMatrix(const Eigen::Vector4f &origin, const Eigen::Quaternion< float > &orientation, vtkSmartPointer< vtkMatrix4x4 > &vtk_matrix)
Convert origin and orientation to vtkMatrix4x4.
bool wasStopped() const
Returns true when the user tried to close the window.
void setLookUpTableID(const std::string id)
Set the ID of a cloud or shape to be used for LUT display.
bool addPlane(const pcl::ModelCoefficients &coefficients, double x, double y, double z, const std::string &id="plane", int viewport=0)
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.
void setCameraFieldOfView(double fovy, int viewport=0)
Set the camera vertical field of view.
void removeOrientationMarkerWidgetAxes()
Disables the Orientatation Marker Widget so it is removed from the renderer.
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.
bool addCone(const pcl::ModelCoefficients &coefficients, const std::string &id="cone", int viewport=0)
Add a cone from a set of given model coefficients.
int getGeometryHandlerIndex(const std::string &id)
Get the geometry handler index of a rendered PointCloud based on its ID.
vtkSmartPointer< vtkRenderWindow > getRenderWindow()
Return a pointer to the underlying VTK Render Window used.
void enableEDLRendering(int viewport=0)
Eye-Dome Lighting makes dark areas to improve depth perception See https://www.kitware....
void spinOnce(int time=1, bool force_redraw=false)
Spin once method.
PCLVisualizer(const std::string &name="", const bool create_interactor=true)
PCL Visualizer constructor.
void setSize(int xw, int yw)
Set the window size in screen coordinates.
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.
bool removeAllPointClouds(int viewport=0)
Remove all point cloud data on screen from the given viewport.
ColorHandler::ConstPtr ColorHandlerConstPtr
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.
bool addModelFromPLYFile(const std::string &filename, const std::string &id="PLYModel", int viewport=0)
Add a PLYmodel as a mesh.
void setCameraParameters(const Camera &camera, int viewport=0)
Set the camera parameters by given a full camera data structure.
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.
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.
void setUseVbos(bool use_vbos)
Use Vertex Buffer Objects renderers.
bool loadCameraParameters(const std::string &file)
Load camera parameters from a camera parameters file.
void setShowFPS(bool show_fps)
Sets whether the 2D overlay text showing the framerate of the window is displayed or not.
bool getCameraParameters(int argc, char **argv)
Search for camera parameters at the command line and set them internally.
int getColorHandlerIndex(const std::string &id)
Get the color handler index of a rendered PointCloud based on its ID.
void setupInteractor(vtkRenderWindowInteractor *iren, vtkRenderWindow *win)
Set up our unique PCL interactor style for a given vtkRenderWindowInteractor object attached to a giv...
void setCameraClipDistances(double near, double far, int viewport=0)
Set the camera clipping distances.
void createInteractor()
Create the internal Interactor object.
bool addCube(const pcl::ModelCoefficients &coefficients, const std::string &id="cube", int viewport=0)
Add a cube from a set of given model coefficients.
bool removeAllShapes(int viewport=0)
Remove all 3D shape data on screen from the given viewport.
float getFPS() const
Get the current rendering framerate.
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.
boost::signals2::connection registerKeyboardCallback(void(*callback)(const pcl::visualization::KeyboardEvent &, void *), void *cookie=nullptr)
Register a callback function for keyboard events.
bool setShapeRenderingProperties(int property, double value, const std::string &id, int viewport=0)
Set the rendering properties of a shape.
void initCameraParameters()
Initialize camera parameters with some default values.
PCLVisualizer(int &argc, char **argv, const std::string &name="", PCLVisualizerInteractorStyle *style=PCLVisualizerInteractorStyle::New(), const bool create_interactor=true)
PCL Visualizer constructor.
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.
void resetCamera()
Reset camera parameters and render.
boost::signals2::connection registerMouseCallback(void(*callback)(const pcl::visualization::MouseEvent &, void *), void *cookie=nullptr)
Register a callback function for mouse events.
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.
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)
bool removePolygonMesh(const std::string &id="polygon", int viewport=0)
Removes a PolygonMesh from screen, based on a given ID.
bool addPointCloud(const pcl::PointCloud< pcl::PointXYZRGB >::ConstPtr &cloud, const std::string &id="cloud", int viewport=0)
Add a PointXYZRGB Point Cloud to screen.
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.
bool contains(const std::string &id) const
Check if the cloud, shape, or coordinate with the given id was already added to this visualizer.
void setWindowName(const std::string &name)
Set the visualizer window name.
void setWindowBorders(bool mode)
Enables or disable the underlying window borders.
boost::signals2::connection registerPointPickingCallback(void(*callback)(const pcl::visualization::PointPickingEvent &, void *), void *cookie=nullptr)
Register a callback function for point picking events.
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.
bool removeText3D(const std::string &id="cloud", int viewport=0)
Removes an added 3D text from the scene, based on a given ID.
boost::signals2::connection registerAreaPickingCallback(void(*callback)(const pcl::visualization::AreaPickingEvent &, void *), void *cookie=nullptr)
Register a callback function for area picking events.
bool setPointCloudRenderingProperties(int property, double value, const std::string &id="cloud", int viewport=0)
Set the rendering properties of a PointCloud.
bool getPointCloudRenderingProperties(RenderingProperties property, double &val1, double &val2, double &val3, const std::string &id="cloud")
Get the rendering properties of a PointCloud.
void saveScreenshot(const std::string &file)
Save the current rendered image to disk, as a PNG screenshot.
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.
static void convertToEigenMatrix(const vtkSmartPointer< vtkMatrix4x4 > &vtk_matrix, Eigen::Matrix4f &m)
Convert vtkMatrix4x4 to an Eigen4f.
bool addPolylineFromPolygonMesh(const pcl::PolygonMesh &polymesh, const std::string &id="polyline", int viewport=0)
Add a Polygonline from a polygonMesh object to screen.
bool getPointCloudRenderingProperties(int property, double &value, const std::string &id="cloud")
Get the rendering properties of a PointCloud.
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.
bool removeShape(const std::string &id="cloud", int viewport=0)
Removes an added shape from screen (line, polygon, etc.), based on a given ID.
boost::signals2::connection registerMouseCallback(std::function< void(const pcl::visualization::MouseEvent &)> cb)
Register a callback function for mouse events.
void resetStoppedFlag()
Set the stopped flag back to false.
shared_ptr< const PCLVisualizer > ConstPtr
void getCameraParameters(Camera &camera, int viewport=0) const
Get camera parameters of a given viewport (0 means default viewport).
boost::signals2::connection registerKeyboardCallback(std::function< void(const pcl::visualization::KeyboardEvent &)> cb)
Register a callback std::function for keyboard events.
Eigen::Affine3f getViewerPose(int viewport=0)
Get the current viewing pose.
bool addPointCloud(const pcl::PointCloud< pcl::PointXYZ >::ConstPtr &cloud, const std::string &id="cloud", int viewport=0)
Add a PointXYZ Point Cloud to screen.
void addOrientationMarkerWidgetAxes(vtkRenderWindowInteractor *interactor)
Adds a widget which shows an interactive axes display for orientation.
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.
vtkSmartPointer< PCLVisualizerInteractorStyle > getInteractorStyle()
Get a pointer to the current interactor style used.
bool addCylinder(const pcl::ModelCoefficients &coefficients, const std::string &id="cylinder", int viewport=0)
Add a cylinder from a set of given model coefficients.
void setRepresentationToPointsForAllActors()
Changes the visual representation for all actors to points representation.
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)
bool addLine(const pcl::ModelCoefficients &coefficients, const char *id="line", int viewport=0)
Add a line from a set of given model coefficients.
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.
void removeCorrespondences(const std::string &id="correspondences", int viewport=0)
Remove the specified correspondences from the display.
bool addModelFromPolyData(vtkSmartPointer< vtkPolyData > polydata, vtkSmartPointer< vtkTransform > transform, const std::string &id="PolyData", int viewport=0)
Add a vtkPolydata as a mesh.
void setCameraParameters(const Eigen::Matrix3f &intrinsics, const Eigen::Matrix4f &extrinsics, int viewport=0)
Set the camera parameters via an intrinsics and and extrinsics matrix.
bool addSphere(const pcl::ModelCoefficients &coefficients, const std::string &id="sphere", int viewport=0)
Add a sphere from a set of given model coefficients.
PCLVisualizerInteractorStyle defines an unique, custom VTK based interactory style for PCL Visualizer...
shared_ptr< const PointCloudColorHandler< PointCloud > > ConstPtr
Base Handler class for PointCloud colors.
shared_ptr< const PointCloudGeometryHandler< PointCloud > > ConstPtr
Base handler class for PointCloud geometry.
/brief Class representing 3D point picking events.
PCL_EXPORTS vtkIdType fillCells(std::vector< int > &lookup, const std::vector< pcl::Vertices > &vertices, vtkSmartPointer< vtkCellArray > cell_array, int max_size_of_polygon)
RenderingProperties
Set of rendering properties.
Definition common.h:102
shared_ptr< CloudActorMap > CloudActorMapPtr
Definition actor_map.h:97
shared_ptr< ShapeActorMap > ShapeActorMapPtr
Definition actor_map.h:100
shared_ptr< CoordinateActorMap > CoordinateActorMapPtr
Definition actor_map.h:103
PCL_EXPORTS void allocVtkUnstructuredGrid(vtkSmartPointer< vtkUnstructuredGrid > &polydata)
Allocate a new unstructured grid smartpointer.
std::vector< pcl::Correspondence, Eigen::aligned_allocator< pcl::Correspondence > > Correspondences
#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
shared_ptr< const ::pcl::PCLPointCloud2 > ConstPtr
A point structure representing Euclidean xyz coordinates, and the RGB color.