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.
 *
 *  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 Willow Garage, Inc. 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.
 *
 * $Id: pcl_visualizer.h 6220 2012-07-06 22:34:56Z rusu $
 *
 */
#ifndef PCL_PCL_VISUALIZER_H_
#define PCL_PCL_VISUALIZER_H_

// PCL includes
#include <pcl/point_types.h>
#include <pcl/correspondence.h>
#include <pcl/point_cloud.h>
#include <pcl/PolygonMesh.h>
//
#include <pcl/console/print.h>
#include <pcl/visualization/common/common.h>
#include <pcl/visualization/common/shapes.h>
#include <pcl/visualization/window.h>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>
// VTK includes
#include <vtkAxes.h>
#include <vtkFloatArray.h>
#include <vtkAppendPolyData.h>
#include <vtkPointData.h>
#include <vtkPolyData.h>
#include <vtkUnstructuredGrid.h>
#include <vtkTubeFilter.h>
#include <vtkPolyDataMapper.h>
#include <vtkDataSetMapper.h>
#include <vtkCellArray.h>
#include <vtkCommand.h>
#include <vtkPLYReader.h>
#include <vtkTransformFilter.h>
#include <vtkPolyLine.h>
#include <vtkVectorText.h>
#include <vtkFollower.h>
#if ((VTK_MAJOR_VERSION == 5) && (VTK_MINOR_VERSION <= 4))
#include <pcl/visualization/interactor.h>
#else
#include <vtkRenderWindowInteractor.h>
#endif

namespace pcl
{
  namespace visualization
  {
    class PCL_EXPORTS PCLVisualizer
    {
      public:
        typedef PointCloudGeometryHandler<sensor_msgs::PointCloud2> GeometryHandler;
        typedef GeometryHandler::Ptr GeometryHandlerPtr;
        typedef GeometryHandler::ConstPtr GeometryHandlerConstPtr;

        typedef PointCloudColorHandler<sensor_msgs::PointCloud2> 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 ();

        inline void
        setFullScreen (bool mode)
        {
          if (win_)
            win_->SetFullScreen (mode);
        }

        inline void
        setWindowBorders (bool mode)
        {
          if (win_)
            win_->SetBorders (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);

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

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

        void
        spin ();

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

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

        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, double scale = 0.02,
                              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, double scale = 0.02,
                              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, double scale = 1.0,
            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");

//        bool
//        updatePointCloud (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr &cloud,
//                          const PointCloudColorHandlerRGBField<pcl::PointXYZRGB> &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 sensor_msgs::PointCloud2::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 sensor_msgs::PointCloud2::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 sensor_msgs::PointCloud2::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
        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,
                            const std::string &id = "correspondences",
                            int viewport = 0);

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

        inline int
        getColorHandlerIndex (const std::string &id)
        {
          CloudActorMap::iterator am_it = style_->getCloudActorMap ()->find (id);
          if (am_it == cloud_actor_map_->end ())
            return (-1);

          return (am_it->second.color_handler_index_);
        }

        inline int
        getGeometryHandlerIndex (const std::string &id)
        {
          CloudActorMap::iterator am_it = style_->getCloudActorMap ()->find (id);
          if (am_it != cloud_actor_map_->end ())
            return (-1);

          return (am_it->second.geometry_handler_index_);
        }

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

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

        bool
        wasStopped () const { if (interactor_ != NULL) return (interactor_->stopped); else return true; }

        void
        resetStoppedFlag () { if (interactor_ != NULL) interactor_->stopped = false; }
#else

        bool
        wasStopped () const { if (interactor_ != NULL) return (stopped_); else return (true); }

        void
        resetStoppedFlag () { if (interactor_ != NULL) stopped_ = false; }
#endif

        void
        close ()
        {
#if ((VTK_MAJOR_VERSION == 5) && (VTK_MINOR_VERSION <= 4))
          interactor_->stopped = true;
          // This tends to close the window...
          interactor_->stopLoop ();
#else
          stopped_ = true;
          // This tends to close the window...
          interactor_->TerminateApp ();
#endif
        }

        void
        createViewPort (double xmin, double ymin, double xmax, double ymax, 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 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 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
        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 (double x_min, double x_max,
                 double y_min, double y_max,
                 double z_min, double 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
        renderView (int xres, int yres, pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud);

        void
        renderViewTesselatedSphere (
            int xres, int yres,
            std::vector<pcl::PointCloud<pcl::PointXYZ>,Eigen::aligned_allocator< pcl::PointCloud<pcl::PointXYZ> > > & 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);

        Camera camera_;

        void
        initCameraParameters ();

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

        bool
        cameraParamsSet () const;

        void
        updateCamera ();

        void
        resetCamera ();

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

        void
        setCameraPose (double posX, double posY, double posZ,
                       double viewX, double viewY, double viewZ,
                       double upX, double upY, double upZ, int viewport = 0);

        void
        setCameraPosition (double posX,double posY, double posZ,
                           double viewX, double viewY, double viewZ, int viewport = 0);

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

        Eigen::Affine3f
        getViewerPose ();

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

        vtkSmartPointer<vtkRenderWindow>
        getRenderWindow ()
        {
          return (win_);
        }

        void
        createInteractor ();

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

        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* vtkNotUsed(caller), unsigned long event_id, void* call_data)
          {
            if (event_id != vtkCommand::TimerEvent)
              return;
            int timer_id = *(int*)call_data;
            //PCL_WARN ("[pcl::visualization::PCLVisualizer::ExitMainLoopTimerCallback] Timer %d called.\n", timer_id);
            if (timer_id != right_timer_id)
              return;
            // Stop vtk loop and send notification to app to wake it up
#if ((VTK_MAJOR_VERSION == 5) && (VTK_MINOR_VERSION <= 4))
            pcl_visualizer->interactor_->stopLoop ();
#else
            pcl_visualizer->interactor_->TerminateApp ();
#endif
          }
          int right_timer_id;
          PCLVisualizer* pcl_visualizer;
        };
        struct ExitCallback : public vtkCommand
        {
          static ExitCallback* New ()
          {
            return new ExitCallback;
          }
          virtual void Execute (vtkObject* caller, unsigned long event_id, void* call_data)
          {
            if (event_id != vtkCommand::ExitEvent)
              return;
#if ((VTK_MAJOR_VERSION == 5) && (VTK_MINOR_VERSION <= 4))
            pcl_visualizer->interactor_->stopped = true;
            // This tends to close the window...
            pcl_visualizer->interactor_->stopLoop ();
#else
            pcl_visualizer->stopped_ = true;
            // This tends to close the window...
            pcl_visualizer->interactor_->TerminateApp ();
#endif
          }
          PCLVisualizer* pcl_visualizer;
        };

#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_;

        bool camera_set_;

        bool
        removeActorFromRenderer (const vtkSmartPointer<vtkLODActor> &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<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);

        void
        convertToVtkMatrix (const Eigen::Matrix4f &m,
                            vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);

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

    };
  }
}

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

#endif