Point Cloud Library (PCL)  1.7.0
/tmp/buildd/pcl-1.7-1.7.0/visualization/include/pcl/visualization/cloud_viewer.h
00001 /*
00002  * Software License Agreement (BSD License)
00003  *
00004  *  Copyright (c) 2011, Willow Garage, Inc.
00005  *  All rights reserved.
00006  *
00007  *  Redistribution and use in source and binary forms, with or without
00008  *  modification, are permitted provided that the following conditions
00009  *  are met:
00010  *
00011  *   * Redistributions of source code must retain the above copyright
00012  *     notice, this list of conditions and the following disclaimer.
00013  *   * Redistributions in binary form must reproduce the above
00014  *     copyright notice, this list of conditions and the following
00015  *     disclaimer in the documentation and/or other materials provided
00016  *     with the distribution.
00017  *   * Neither the name of Willow Garage, Inc. nor the names of its
00018  *     contributors may be used to endorse or promote products derived
00019  *     from this software without specific prior written permission.
00020  *
00021  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00022  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00023  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
00024  *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
00025  *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
00026  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
00027  *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
00028  *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
00029  *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
00030  *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
00031  *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00032  *  POSSIBILITY OF SUCH DAMAGE.
00033  *
00034  *
00035  */
00036 #ifndef PCL_CLOUD_VIEWER_H_
00037 #define PCL_CLOUD_VIEWER_H_
00038 
00039 #include <pcl/visualization/pcl_visualizer.h> //pcl vis
00040 
00041 #include <string>
00042 
00043 namespace pcl
00044 {
00045   namespace visualization
00046   {
00047     /** \brief Simple point cloud visualization class
00048       * \author Ethan Rublee
00049       * \ingroup visualization
00050       */
00051     class PCL_EXPORTS CloudViewer : boost::noncopyable
00052     {
00053       public:
00054         typedef pcl::PointCloud<pcl::PointXYZRGBA> ColorACloud;
00055         typedef pcl::PointCloud<pcl::PointXYZRGB> ColorCloud;
00056         typedef pcl::PointCloud<pcl::PointXYZI> GrayCloud;
00057         typedef pcl::PointCloud<pcl::PointXYZ> MonochromeCloud;
00058 
00059         /** \brief Construct a cloud viewer, with a window name.
00060          * \param window_name This is displayed at the top of the window
00061          */
00062         CloudViewer (const std::string& window_name);
00063 
00064         /** \brief Will quit the window,
00065          * and release all resources held by the viewer.
00066          * @return
00067          */
00068         ~CloudViewer ();
00069 
00070         /** \brief Show a cloud, with an optional key for multiple clouds.
00071           * \param[in] cloud RGB point cloud
00072           * \param[in] cloudname a key for the point cloud, use the same name if you would like to overwrite the existing cloud.
00073           */
00074         void
00075         showCloud (const ColorCloud::ConstPtr &cloud, const std::string& cloudname = "cloud");
00076 
00077         /** \brief Show a cloud, with an optional key for multiple clouds.
00078           * \param[in] cloud RGB point cloud
00079           * \param[in] cloudname a key for the point cloud, use the same name if you would like to overwrite the existing cloud.
00080           */
00081         void
00082         showCloud (const ColorACloud::ConstPtr &cloud, const std::string& cloudname = "cloud");
00083 
00084         /** \brief Show a cloud, with an optional key for multiple clouds.
00085           * \param[in] cloud XYZI point cloud
00086           * \param[in] cloudname a key for the point cloud, use the same name if you would like to overwrite the existing cloud.
00087           */
00088         void
00089         showCloud (const GrayCloud::ConstPtr &cloud, const std::string& cloudname = "cloud");
00090 
00091 
00092         /** \brief Show a cloud, with an optional key for multiple clouds.
00093           * \param[in] cloud XYZ point cloud
00094           * \param[in] cloudname a key for the point cloud, use the same name if you would like to overwrite the existing cloud.
00095           */
00096         void
00097         showCloud (const MonochromeCloud::ConstPtr &cloud, const std::string& cloudname = "cloud");
00098         
00099         /** \brief Check if the gui was quit, you should quit also
00100          * \param millis_to_wait This will request to "spin" for the number of milliseconds, before exiting.
00101          * \return true if the user signaled the gui to stop
00102          */
00103         bool
00104         wasStopped (int millis_to_wait = 1);
00105 
00106         /** Visualization callable function, may be used for running things on the UI thread.
00107          */
00108         typedef boost::function1<void, pcl::visualization::PCLVisualizer&> VizCallable;
00109 
00110         /** \brief Run a callbable object on the UI thread. Will persist until removed
00111          * @param x Use boost::ref(x) for a function object that you would like to not copy
00112          * \param key The key for the callable -- use the same key to overwrite.
00113          */
00114         void
00115         runOnVisualizationThread (VizCallable x, const std::string& key = "callable");
00116 
00117         /** \brief Run a callbable object on the UI thread. This will run once and be removed
00118          * @param x Use boost::ref(x) for a function object that you would like to not copy
00119          */
00120         void
00121         runOnVisualizationThreadOnce (VizCallable x);
00122 
00123         /** \brief Remove a previously added callable object, NOP if it doesn't exist.
00124          * @param key the key that was registered with the callable object.
00125          */
00126         void
00127         removeVisualizationCallable (const std::string& key = "callable");
00128         
00129         /** \brief Register a callback function for keyboard events
00130           * \param[in] callback  the function that will be registered as a callback for a keyboard event
00131           * \param[in] cookie    user data that is passed to the callback
00132           * \return              connection object that allows to disconnect the callback function.
00133           */
00134         inline boost::signals2::connection 
00135         registerKeyboardCallback (void (*callback) (const pcl::visualization::KeyboardEvent&, void*), void* cookie = NULL)
00136         {
00137           return (registerKeyboardCallback (boost::bind (callback, _1, cookie)));
00138         }
00139         
00140         /** \brief Register a callback function for keyboard events
00141           * \param[in] callback  the member function that will be registered as a callback for a keyboard event
00142           * \param[in] instance  instance to the class that implements the callback function
00143           * \param[in] cookie    user data that is passed to the callback
00144           * \return              connection object that allows to disconnect the callback function.
00145           */
00146         template<typename T> inline boost::signals2::connection 
00147         registerKeyboardCallback (void (T::*callback) (const pcl::visualization::KeyboardEvent&, void*), T& instance, void* cookie = NULL)
00148         {
00149           return (registerKeyboardCallback (boost::bind (callback,  boost::ref (instance), _1, cookie)));
00150         }
00151         
00152         /** \brief Register a callback function for mouse events
00153           * \param[in] callback  the function that will be registered as a callback for a mouse event
00154           * \param[in] cookie    user data that is passed to the callback
00155           * \return              connection object that allows to disconnect the callback function.
00156           */
00157         inline boost::signals2::connection 
00158         registerMouseCallback (void (*callback) (const pcl::visualization::MouseEvent&, void*), void* cookie = NULL)
00159         {
00160           return (registerMouseCallback (boost::bind (callback, _1, cookie)));
00161         }
00162         
00163         /** \brief Register a callback function for mouse events
00164           * \param[in] callback  the member function that will be registered as a callback for a mouse event
00165           * \param[in] instance  instance to the class that implements the callback function
00166           * \param[in] cookie    user data that is passed to the callback
00167           * \return              connection object that allows to disconnect the callback function.
00168           */
00169         template<typename T> inline boost::signals2::connection 
00170         registerMouseCallback (void (T::*callback) (const pcl::visualization::MouseEvent&, void*), T& instance, void* cookie = NULL)
00171         {
00172           return (registerMouseCallback (boost::bind (callback, boost::ref (instance), _1, cookie)));
00173         }
00174 
00175         
00176         /** \brief Register a callback function for point picking events
00177           * \param[in] callback  the function that will be registered as a callback for a point picking event
00178           * \param[in] cookie    user data that is passed to the callback
00179           * \return              connection object that allows to disconnect the callback function.
00180           */
00181         inline boost::signals2::connection 
00182         registerPointPickingCallback (void (*callback) (const pcl::visualization::PointPickingEvent&, void*), void* cookie = NULL)
00183         {
00184           return (registerPointPickingCallback (boost::bind (callback, _1, cookie)));
00185         }
00186         
00187         /** \brief Register a callback function for point picking events
00188           * \param[in] callback  the member function that will be registered as a callback for a point picking event
00189           * \param[in] instance  instance to the class that implements the callback function
00190           * \param[in] cookie    user data that is passed to the callback
00191           * \return              connection object that allows to disconnect the callback function.
00192           */
00193         template<typename T> inline boost::signals2::connection 
00194         registerPointPickingCallback (void (T::*callback) (const pcl::visualization::PointPickingEvent&, void*), T& instance, void* cookie = NULL)
00195         {
00196           return (registerPointPickingCallback (boost::bind (callback, boost::ref (instance), _1, cookie)));
00197         }
00198         
00199       private:
00200         /** \brief Private implementation. */
00201         struct CloudViewer_impl;
00202         std::auto_ptr<CloudViewer_impl> impl_;
00203         
00204         boost::signals2::connection 
00205         registerMouseCallback (boost::function<void (const pcl::visualization::MouseEvent&)>);
00206 
00207         boost::signals2::connection 
00208         registerKeyboardCallback (boost::function<void (const pcl::visualization::KeyboardEvent&)>);
00209 
00210         boost::signals2::connection 
00211         registerPointPickingCallback (boost::function<void (const pcl::visualization::PointPickingEvent&)>);
00212     };
00213   }
00214 }
00215 
00216 #endif /* CLOUD_VIEWER_H_ */