pcl_visualizer.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 *  Point Cloud Library (PCL) - www.pointclouds.org
 *  Copyright (c) 2010-2011, Willow Garage, Inc.
 *  Copyright (c) 2012-, Open Perception, Inc.
 *
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *   * Neither the name of the copyright holder(s) nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 */
#ifndef PCL_PCL_VISUALIZER_H_
#define PCL_PCL_VISUALIZER_H_

// PCL includes
#include <pcl/correspondence.h>
#include <pcl/ModelCoefficients.h>
#include <pcl/PolygonMesh.h>
//
#include <pcl/console/print.h>
#include <pcl/visualization/common/actor_map.h>
#include <pcl/visualization/common/common.h>
#include <pcl/visualization/point_cloud_geometry_handlers.h>
#include <pcl/visualization/point_cloud_color_handlers.h>
#include <pcl/visualization/point_picking_event.h>
#include <pcl/visualization/area_picking_event.h>
#include <pcl/visualization/interactor_style.h>

// VTK includes
class vtkPolyData;
class vtkTextActor;
class vtkRenderWindow;
class vtkOrientationMarkerWidget;
class vtkAppendPolyData;
class vtkRenderWindow;
class vtkRenderWindowInteractor;
class vtkTransform;
class vtkInteractorStyle;
class vtkLODActor;
class vtkProp;
class vtkActor;
class vtkDataSet;
class vtkUnstructuredGrid;

namespace pcl
{
  template <typename T> class PointCloud;
  template <typename T> class PlanarPolygon;

  namespace visualization
  {
    class PCL_EXPORTS PCLVisualizer
    {
      public:
        typedef boost::shared_ptr<PCLVisualizer> Ptr;
        typedef boost::shared_ptr<const PCLVisualizer> ConstPtr;

        typedef PointCloudGeometryHandler<pcl::PCLPointCloud2> GeometryHandler;
        typedef GeometryHandler::Ptr GeometryHandlerPtr;
        typedef GeometryHandler::ConstPtr GeometryHandlerConstPtr;

        typedef PointCloudColorHandler<pcl::PCLPointCloud2> ColorHandler;
        typedef ColorHandler::Ptr ColorHandlerPtr;
        typedef ColorHandler::ConstPtr ColorHandlerConstPtr;

        PCLVisualizer (const std::string &name = "", const bool create_interactor = true);

        PCLVisualizer (int &argc, char **argv, const std::string &name = "",
            PCLVisualizerInteractorStyle* style = PCLVisualizerInteractorStyle::New (), const bool create_interactor = true);

        virtual ~PCLVisualizer ();

        void
        setFullScreen (bool mode);

        void
        setWindowName (const std::string &name);

        void
        setWindowBorders (bool mode);

        boost::signals2::connection
        registerKeyboardCallback (boost::function<void (const pcl::visualization::KeyboardEvent&)> cb);

        inline boost::signals2::connection
        registerKeyboardCallback (void (*callback) (const pcl::visualization::KeyboardEvent&, void*), void* cookie = NULL)
        {
          return (registerKeyboardCallback (boost::bind (callback, _1, cookie)));
        }

        template<typename T> inline boost::signals2::connection
        registerKeyboardCallback (void (T::*callback) (const pcl::visualization::KeyboardEvent&, void*), T& instance, void* cookie = NULL)
        {
          return (registerKeyboardCallback (boost::bind (callback,  boost::ref (instance), _1, cookie)));
        }

        boost::signals2::connection
        registerMouseCallback (boost::function<void (const pcl::visualization::MouseEvent&)> cb);

        inline boost::signals2::connection
        registerMouseCallback (void (*callback) (const pcl::visualization::MouseEvent&, void*), void* cookie = NULL)
        {
          return (registerMouseCallback (boost::bind (callback, _1, cookie)));
        }

        template<typename T> inline boost::signals2::connection
        registerMouseCallback (void (T::*callback) (const pcl::visualization::MouseEvent&, void*), T& instance, void* cookie = NULL)
        {
          return (registerMouseCallback (boost::bind (callback, boost::ref (instance), _1, cookie)));
        }

        boost::signals2::connection
        registerPointPickingCallback (boost::function<void (const pcl::visualization::PointPickingEvent&)> cb);

        boost::signals2::connection
        registerPointPickingCallback (void (*callback) (const pcl::visualization::PointPickingEvent&, void*), void* cookie = NULL);

        template<typename T> inline boost::signals2::connection
        registerPointPickingCallback (void (T::*callback) (const pcl::visualization::PointPickingEvent&, void*), T& instance, void* cookie = NULL)
        {
          return (registerPointPickingCallback (boost::bind (callback, boost::ref (instance), _1, cookie)));
        }

        boost::signals2::connection
        registerAreaPickingCallback (boost::function<void (const pcl::visualization::AreaPickingEvent&)> cb);

        boost::signals2::connection
        registerAreaPickingCallback (void (*callback) (const pcl::visualization::AreaPickingEvent&, void*), void* cookie = NULL);

        template<typename T> inline boost::signals2::connection
        registerAreaPickingCallback (void (T::*callback) (const pcl::visualization::AreaPickingEvent&, void*), T& instance, void* cookie = NULL)
        {
          return (registerAreaPickingCallback (boost::bind (callback, boost::ref (instance), _1, cookie)));
        }

        void
        spin ();

        void
        spinOnce (int time = 1, bool force_redraw = false);

        void
        addOrientationMarkerWidgetAxes (vtkRenderWindowInteractor* interactor);
        
        void
        removeOrientationMarkerWidgetAxes ();
        
        void
        addCoordinateSystem (double scale = 1.0, int viewport = 0);

        void
        addCoordinateSystem (double scale, float x, float y, float z, int viewport = 0);

        void
        addCoordinateSystem (double scale, const Eigen::Affine3f& t, int viewport = 0);

        bool
        removeCoordinateSystem (int viewport = 0);

        bool
        removePointCloud (const std::string &id = "cloud", int viewport = 0);

        inline bool
        removePolygonMesh (const std::string &id = "polygon", int viewport = 0)
        {
          // Polygon Meshes are represented internally as point clouds with special cell array structures since 1.4
          return (removePointCloud (id, viewport));
        }

        bool
        removeShape (const std::string &id = "cloud", int viewport = 0);

        bool
        removeText3D (const std::string &id = "cloud", int viewport = 0);

        bool
        removeAllPointClouds (int viewport = 0);

        bool
        removeAllShapes (int viewport = 0);

        void
        setBackgroundColor (const double &r, const double &g, const double &b, int viewport = 0);

        bool
        addText (const std::string &text,
                 int xpos, int ypos,
                 const std::string &id = "", int viewport = 0);

        bool
        addText (const std::string &text, int xpos, int ypos, double r, double g, double b,
                 const std::string &id = "", int viewport = 0);

        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);


        bool
        updateText (const std::string &text,
                    int xpos, int ypos,
                    const std::string &id = "");

        bool
        updateText (const std::string &text, 
                    int xpos, int ypos, double r, double g, double b,
                    const std::string &id = "");

        bool
        updateText (const std::string &text, 
                    int xpos, int ypos, int fontsize, double r, double g, double b,
                    const std::string &id = "");

        bool
        updateShapePose (const std::string &id, const Eigen::Affine3f& pose);

        bool
        updatePointCloudPose (const std::string &id, const Eigen::Affine3f& pose);

        template <typename PointT> bool
        addText3D (const std::string &text,
                   const PointT &position,
                   double textScale = 1.0,
                   double r = 1.0, double g = 1.0, double b = 1.0,
                   const std::string &id = "", int viewport = 0);

        template <typename PointNT> bool
        addPointCloudNormals (const typename pcl::PointCloud<PointNT>::ConstPtr &cloud,
                              int level = 100, float scale = 0.02f,
                              const std::string &id = "cloud", int viewport = 0);

        template <typename PointT, typename PointNT> bool
        addPointCloudNormals (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                              const typename pcl::PointCloud<PointNT>::ConstPtr &normals,
                              int level = 100, float scale = 0.02f,
                              const std::string &id = "cloud", int viewport = 0);

        bool
        addPointCloudPrincipalCurvatures (
            const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &cloud,
            const pcl::PointCloud<pcl::Normal>::ConstPtr &normals,
            const pcl::PointCloud<pcl::PrincipalCurvatures>::ConstPtr &pcs,
            int level = 100, float scale = 1.0f,
            const std::string &id = "cloud", int viewport = 0);

        template <typename PointT, typename GradientT> bool
        addPointCloudIntensityGradients (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                                         const typename pcl::PointCloud<GradientT>::ConstPtr &gradients,
                                         int level = 100, double scale = 1e-6,
                                         const std::string &id = "cloud", int viewport = 0);

        template <typename PointT> bool
        addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                       const std::string &id = "cloud", int viewport = 0);

        template <typename PointT> bool
        updatePointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                          const std::string &id = "cloud");

        template <typename PointT> bool
        updatePointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                          const PointCloudGeometryHandler<PointT> &geometry_handler,
                          const std::string &id = "cloud");

        template <typename PointT> bool
        updatePointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                          const PointCloudColorHandler<PointT> &color_handler,
                          const std::string &id = "cloud");

        template <typename PointT> bool
        addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                       const PointCloudGeometryHandler<PointT> &geometry_handler,
                       const std::string &id = "cloud", int viewport = 0);

        template <typename PointT> bool
        addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                       const GeometryHandlerConstPtr &geometry_handler,
                       const std::string &id = "cloud", int viewport = 0);

        template <typename PointT> bool
        addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                       const PointCloudColorHandler<PointT> &color_handler,
                       const std::string &id = "cloud", int viewport = 0);

        template <typename PointT> bool
        addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                       const ColorHandlerConstPtr &color_handler,
                       const std::string &id = "cloud", int viewport = 0);

        template <typename PointT> bool
        addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                       const GeometryHandlerConstPtr &geometry_handler,
                       const ColorHandlerConstPtr &color_handler,
                       const std::string &id = "cloud", int viewport = 0);

        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);

        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);

        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);

        template <typename PointT> bool
        addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                       const PointCloudColorHandler<PointT> &color_handler,
                       const PointCloudGeometryHandler<PointT> &geometry_handler,
                       const std::string &id = "cloud", int viewport = 0);

        inline bool
        addPointCloud (const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &cloud,
                       const std::string &id = "cloud", int viewport = 0)
        {
          return (addPointCloud<pcl::PointXYZ> (cloud, id, viewport));
        }


        inline bool
        addPointCloud (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr &cloud,
                       const std::string &id = "cloud", int viewport = 0)
        {
          pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> color_handler (cloud);
          return (addPointCloud<pcl::PointXYZRGB> (cloud, color_handler, id, viewport));
        }

        inline bool
        addPointCloud (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud,
                       const std::string &id = "cloud", int viewport = 0)
        {
          pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGBA> color_handler (cloud);
          return (addPointCloud<pcl::PointXYZRGBA> (cloud, color_handler, id, viewport));
        }

        inline bool
        updatePointCloud (const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &cloud,
                          const std::string &id = "cloud")
        {
          return (updatePointCloud<pcl::PointXYZ> (cloud, id));
        }

        inline bool
        updatePointCloud (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr &cloud,
                          const std::string &id = "cloud")
        {
          pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> color_handler (cloud);
          return (updatePointCloud<pcl::PointXYZRGB> (cloud, color_handler, id));
        }

        inline bool
        updatePointCloud (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud,
                          const std::string &id = "cloud")
        {
          pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGBA> color_handler (cloud);
          return (updatePointCloud<pcl::PointXYZRGBA> (cloud, color_handler, id));
        }

        bool
        addPolygonMesh (const pcl::PolygonMesh &polymesh,
                        const std::string &id = "polygon",
                        int viewport = 0);

        template <typename PointT> bool
        addPolygonMesh (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                        const std::vector<pcl::Vertices> &vertices,
                        const std::string &id = "polygon",
                        int viewport = 0);

        template <typename PointT> bool
        updatePolygonMesh (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                           const std::vector<pcl::Vertices> &vertices,
                           const std::string &id = "polygon");

        bool
        updatePolygonMesh (const pcl::PolygonMesh &polymesh,
                           const std::string &id = "polygon");

        bool
        addPolylineFromPolygonMesh (const pcl::PolygonMesh &polymesh,
                                    const std::string &id = "polyline",
                                    int viewport = 0);

        template <typename PointT> bool
        addCorrespondences (const typename pcl::PointCloud<PointT>::ConstPtr &source_points,
                            const typename pcl::PointCloud<PointT>::ConstPtr &target_points,
                            const std::vector<int> & correspondences,
                            const std::string &id = "correspondences",
                            int viewport = 0);

        template <typename PointT> bool
        addCorrespondences (const typename pcl::PointCloud<PointT>::ConstPtr &source_points,
                            const typename pcl::PointCloud<PointT>::ConstPtr &target_points,
                            const pcl::Correspondences &correspondences,
                            int nth,
                            const std::string &id = "correspondences",
                            int viewport = 0);

        template <typename PointT> 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)
        {
          // If Nth not given, display all correspondences
          return (addCorrespondences<PointT> (source_points, target_points, 
                                              correspondences, 1, id, viewport));
        }

        template <typename PointT> bool
        updateCorrespondences (
            const typename pcl::PointCloud<PointT>::ConstPtr &source_points,
            const typename pcl::PointCloud<PointT>::ConstPtr &target_points,
            const pcl::Correspondences &correspondences,
            int nth,
            const std::string &id = "correspondences");

        void
        removeCorrespondences (const std::string &id = "correspondences", int viewport = 0);

        int
        getColorHandlerIndex (const std::string &id);

        int
        getGeometryHandlerIndex (const std::string &id);

        bool
        updateColorHandlerIndex (const std::string &id, int index);

        bool
        setPointCloudRenderingProperties (int property, double val1, double val2, double val3,
                                          const std::string &id = "cloud", int viewport = 0);

        bool
        setPointCloudRenderingProperties (int property, double value,
                                          const std::string &id = "cloud", int viewport = 0);

        bool
        getPointCloudRenderingProperties (int property, double &value,
                                          const std::string &id = "cloud");
        
        bool
        setPointCloudSelected (const bool selected, const std::string &id = "cloud" );
        
        bool
        setShapeRenderingProperties (int property, double value,
                                     const std::string &id, int viewport = 0);

         bool
         setShapeRenderingProperties (int property, double val1, double val2, double val3,
                                      const std::string &id, int viewport = 0);

        bool
        wasStopped () const;

        void
        resetStoppedFlag ();

        void
        close ();

        void
        createViewPort (double xmin, double ymin, double xmax, double ymax, int &viewport);

        void
        createViewPortCamera (const int viewport);

        template <typename PointT> bool
        addPolygon (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                    double r, double g, double b,
                    const std::string &id = "polygon", int viewport = 0);

        template <typename PointT> bool
        addPolygon (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                    const std::string &id = "polygon",
                    int viewport = 0);

        template <typename PointT> bool
        addPolygon (const pcl::PlanarPolygon<PointT> &polygon,
                    double r, double g, double b,
                    const std::string &id = "polygon",
                    int viewport = 0);

        template <typename P1, typename P2> bool
        addLine (const P1 &pt1, const P2 &pt2, const std::string &id = "line",
                 int viewport = 0);

        template <typename P1, typename P2> bool
        addLine (const P1 &pt1, const P2 &pt2, double r, double g, double b,
                 const std::string &id = "line", int viewport = 0);

        template <typename P1, typename P2> bool
        addArrow (const P1 &pt1, const P2 &pt2, double r, double g, double b,
                  const std::string &id = "arrow", int viewport = 0);

        template <typename P1, typename P2> bool
        addArrow (const P1 &pt1, const P2 &pt2, double r, double g, double b, bool display_length,
                  const std::string &id = "arrow", int viewport = 0);

              template <typename P1, typename P2> bool
              addArrow (const P1 &pt1, const P2 &pt2,
                              double r_line, double g_line, double b_line,
                              double r_text, double g_text, double b_text,
                              const std::string &id = "arrow", int viewport = 0);


        template <typename PointT> bool
        addSphere (const PointT &center, double radius, const std::string &id = "sphere",
                   int viewport = 0);

        template <typename PointT> bool
        addSphere (const PointT &center, double radius, double r, double g, double b,
                   const std::string &id = "sphere", int viewport = 0);

        template <typename PointT> bool
        updateSphere (const PointT &center, double radius, double r, double g, double b,
                      const std::string &id = "sphere");

        bool
        addModelFromPolyData (vtkSmartPointer<vtkPolyData> polydata,
                              const std::string & id = "PolyData",
                              int viewport = 0);

        bool
        addModelFromPolyData (vtkSmartPointer<vtkPolyData> polydata,
                              vtkSmartPointer<vtkTransform> transform,
                              const std::string &id = "PolyData",
                              int viewport = 0);

        bool
        addModelFromPLYFile (const std::string &filename,
                             const std::string &id = "PLYModel",
                             int viewport = 0);

        bool
        addModelFromPLYFile (const std::string &filename,
                             vtkSmartPointer<vtkTransform> transform,
                             const std::string &id = "PLYModel",
                             int viewport = 0);

        bool
        addCylinder (const pcl::ModelCoefficients &coefficients,
                     const std::string &id = "cylinder",
                     int viewport = 0);

        bool
        addSphere (const pcl::ModelCoefficients &coefficients,
                   const std::string &id = "sphere",
                   int viewport = 0);

        bool
        addLine (const pcl::ModelCoefficients &coefficients,
                 const std::string &id = "line",
                 int viewport = 0);

        bool
        addPlane (const pcl::ModelCoefficients &coefficients,
                  const std::string &id = "plane",
                  int viewport = 0);

        bool
        addPlane (const pcl::ModelCoefficients &coefficients, double x, double y, double z,
                  const std::string &id = "plane",
                  int viewport = 0);
        bool
        addCircle (const pcl::ModelCoefficients &coefficients,
                   const std::string &id = "circle",
                   int viewport = 0);

        bool
        addCone (const pcl::ModelCoefficients &coefficients,
                 const std::string &id = "cone",
                 int viewport = 0);

        bool
        addCube (const pcl::ModelCoefficients &coefficients,
                 const std::string &id = "cube",
                 int viewport = 0);

        bool
        addCube (const Eigen::Vector3f &translation, const Eigen::Quaternionf &rotation,
                 double width, double height, double depth,
                 const std::string &id = "cube",
                 int viewport = 0);

        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);

        void
        setRepresentationToSurfaceForAllActors ();

        void
        setRepresentationToPointsForAllActors ();

        void
        setRepresentationToWireframeForAllActors ();

        void
        setShowFPS (bool show_fps);

        void
        renderView (int xres, int yres, pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud);

        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);


        void
        initCameraParameters ();

        bool
        getCameraParameters (int argc, char **argv);

        bool
        cameraParamsSet () const;

        void
        updateCamera ();

        void
        resetCamera ();

        void
        resetCameraViewpoint (const std::string &id = "cloud");

        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);

        void
        setCameraPosition (double pos_x, double pos_y, double pos_z,
                           double up_x, double up_y, double up_z, int viewport = 0);

        void
        setCameraParameters (const Eigen::Matrix3f &intrinsics, const Eigen::Matrix4f &extrinsics, int viewport = 0);

        void
        setCameraParameters (const Camera &camera, int viewport = 0);

        void
        setCameraClipDistances (double near, double far, int viewport = 0);

        void
        setCameraFieldOfView (double fovy, int viewport = 0);

        void
        getCameras (std::vector<Camera>& cameras);


        Eigen::Affine3f
        getViewerPose (int viewport = 0);

        void
        saveScreenshot (const std::string &file);

        vtkSmartPointer<vtkRenderWindow>
        getRenderWindow ()
        {
          return (win_);
        }
        
        vtkSmartPointer<vtkRendererCollection>
        getRendererCollection ()
        {
          return (rens_);
        }
        
        CloudActorMapPtr
        getCloudActorMap ()
        {
          return (cloud_actor_map_);
        }
        

        void
        setPosition (int x, int y);

        void
        setSize (int xw, int yw);

        void
        setUseVbos (bool use_vbos);

        void
        createInteractor ();

        void
        setupInteractor (vtkRenderWindowInteractor *iren,
                         vtkRenderWindow *win);

        void
        setupInteractor (vtkRenderWindowInteractor *iren,
                         vtkRenderWindow *win,
                         vtkInteractorStyle *style);
        
        inline vtkSmartPointer<PCLVisualizerInteractorStyle>
        getInteractorStyle ()
        {
          return (style_);
        }
      protected:
#if ((VTK_MAJOR_VERSION == 5) && (VTK_MINOR_VERSION <= 4))
        vtkSmartPointer<PCLVisualizerInteractor> interactor_;
#else
        vtkSmartPointer<vtkRenderWindowInteractor> interactor_;
#endif
      private:
        struct ExitMainLoopTimerCallback : public vtkCommand
        {
          static ExitMainLoopTimerCallback* New ()
          {
            return (new ExitMainLoopTimerCallback);
          }
          virtual void 
          Execute (vtkObject*, unsigned long event_id, void*);

          int right_timer_id;
          PCLVisualizer* pcl_visualizer;
        };

        struct ExitCallback : public vtkCommand
        {
          static ExitCallback* New ()
          {
            return (new ExitCallback);
          }
          virtual void 
          Execute (vtkObject*, unsigned long event_id, void*);

          PCLVisualizer* pcl_visualizer;
        };

        struct FPSCallback : public vtkCommand
        {
          static FPSCallback *New () { return (new FPSCallback); }

          FPSCallback () : actor (), pcl_visualizer (), decimated () {}
          FPSCallback (const FPSCallback& src) : vtkCommand (), actor (src.actor), pcl_visualizer (src.pcl_visualizer), decimated (src.decimated) {}
          FPSCallback& operator = (const FPSCallback& src) { actor = src.actor; pcl_visualizer = src.pcl_visualizer; decimated = src.decimated; return (*this); }

          virtual void 
          Execute (vtkObject*, unsigned long event_id, void*);
            
          vtkTextActor *actor;
          PCLVisualizer* pcl_visualizer;
          bool decimated;
        };

        vtkSmartPointer<FPSCallback> update_fps_;

#if !((VTK_MAJOR_VERSION == 5) && (VTK_MINOR_VERSION <= 4))

        bool stopped_;

        int timer_id_;
#endif

        vtkSmartPointer<ExitMainLoopTimerCallback> exit_main_loop_timer_callback_;
        vtkSmartPointer<ExitCallback> exit_callback_;

        vtkSmartPointer<vtkRendererCollection> rens_;

        vtkSmartPointer<vtkRenderWindow> win_;

        vtkSmartPointer<PCLVisualizerInteractorStyle> style_;

        CloudActorMapPtr cloud_actor_map_;

        ShapeActorMapPtr shape_actor_map_;

        CoordinateActorMap coordinate_actor_map_;

        vtkSmartPointer<vtkOrientationMarkerWidget> axes_widget_;
        
        bool camera_set_;

        bool use_vbos_;

        bool
        removeActorFromRenderer (const vtkSmartPointer<vtkLODActor> &actor,
                                 int viewport = 0);

        bool
        removeActorFromRenderer (const vtkSmartPointer<vtkActor> &actor,
                                 int viewport = 0);

        void
        addActorToRenderer (const vtkSmartPointer<vtkProp> &actor,
                            int viewport = 0);

        bool
        removeActorFromRenderer (const vtkSmartPointer<vtkProp> &actor,
                                 int viewport = 0);

        void
        createActorFromVTKDataSet (const vtkSmartPointer<vtkDataSet> &data,
                                   vtkSmartPointer<vtkActor> &actor,
                                   bool use_scalars = true);

        void
        createActorFromVTKDataSet (const vtkSmartPointer<vtkDataSet> &data,
                                   vtkSmartPointer<vtkLODActor> &actor,
                                   bool use_scalars = true);

        template <typename PointT> void
        convertPointCloudToVTKPolyData (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
                                        vtkSmartPointer<vtkPolyData> &polydata,
                                        vtkSmartPointer<vtkIdTypeArray> &initcells);

        template <typename PointT> void
        convertPointCloudToVTKPolyData (const PointCloudGeometryHandler<PointT> &geometry_handler,
                                        vtkSmartPointer<vtkPolyData> &polydata,
                                        vtkSmartPointer<vtkIdTypeArray> &initcells);

        void
        convertPointCloudToVTKPolyData (const GeometryHandlerConstPtr &geometry_handler,
                                        vtkSmartPointer<vtkPolyData> &polydata,
                                        vtkSmartPointer<vtkIdTypeArray> &initcells);

        void
        updateCells (vtkSmartPointer<vtkIdTypeArray> &cells,
                     vtkSmartPointer<vtkIdTypeArray> &initcells,
                     vtkIdType nr_points);

        template <typename PointT> bool
        fromHandlersToScreen (const PointCloudGeometryHandler<PointT> &geometry_handler,
                              const PointCloudColorHandler<PointT> &color_handler,
                              const std::string &id,
                              int viewport,
                              const Eigen::Vector4f& sensor_origin = Eigen::Vector4f (0, 0, 0, 0),
                              const Eigen::Quaternion<float>& sensor_orientation = Eigen::Quaternion<float> (1, 0, 0 ,0));

        template <typename PointT> bool
        fromHandlersToScreen (const PointCloudGeometryHandler<PointT> &geometry_handler,
                              const ColorHandlerConstPtr &color_handler,
                              const std::string &id,
                              int viewport,
                              const Eigen::Vector4f& sensor_origin = Eigen::Vector4f (0, 0, 0, 0),
                              const Eigen::Quaternion<float>& sensor_orientation = Eigen::Quaternion<float> (1, 0, 0 ,0));

        bool
        fromHandlersToScreen (const GeometryHandlerConstPtr &geometry_handler,
                              const ColorHandlerConstPtr &color_handler,
                              const std::string &id,
                              int viewport,
                              const Eigen::Vector4f& sensor_origin = Eigen::Vector4f (0, 0, 0, 0),
                              const Eigen::Quaternion<float>& sensor_orientation = Eigen::Quaternion<float> (1, 0, 0 ,0));

        template <typename PointT> bool
        fromHandlersToScreen (const GeometryHandlerConstPtr &geometry_handler,
                              const PointCloudColorHandler<PointT> &color_handler,
                              const std::string &id,
                              int viewport,
                              const Eigen::Vector4f& sensor_origin = Eigen::Vector4f (0, 0, 0, 0),
                              const Eigen::Quaternion<float>& sensor_orientation = Eigen::Quaternion<float> (1, 0, 0 ,0));

        void
        allocVtkPolyData (vtkSmartPointer<vtkAppendPolyData> &polydata);

        void
        allocVtkPolyData (vtkSmartPointer<vtkPolyData> &polydata);

        void
        allocVtkUnstructuredGrid (vtkSmartPointer<vtkUnstructuredGrid> &polydata);

        void
        getTransformationMatrix (const Eigen::Vector4f &origin,
                                 const Eigen::Quaternion<float> &orientation,
                                 Eigen::Matrix4f &transformation);

        //There's no reason these conversion functions shouldn't be public and static so others can use them.
      public:
        static void
        convertToVtkMatrix (const Eigen::Matrix4f &m,
                            vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);

        static void
        convertToVtkMatrix (const Eigen::Vector4f &origin,
                            const Eigen::Quaternion<float> &orientation,
                            vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
        
        static void
        convertToEigenMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix,
                              Eigen::Matrix4f &m);

    };
  }
}

#include <pcl/visualization/impl/pcl_visualizer.hpp>

#endif