Point Cloud Library (PCL)  1.3.1
point_cloud_handlers.h
Go to the documentation of this file.
00001 /*
00002  * Software License Agreement (BSD License)
00003  *
00004  *  Point Cloud Library (PCL) - www.pointclouds.org
00005  *  Copyright (c) 2010-2011, Willow Garage, Inc.
00006  *
00007  *  All rights reserved.
00008  *
00009  *  Redistribution and use in source and binary forms, with or without
00010  *  modification, are permitted provided that the following conditions
00011  *  are met:
00012  *
00013  *   * Redistributions of source code must retain the above copyright
00014  *     notice, this list of conditions and the following disclaimer.
00015  *   * Redistributions in binary form must reproduce the above
00016  *     copyright notice, this list of conditions and the following
00017  *     disclaimer in the documentation and/or other materials provided
00018  *     with the distribution.
00019  *   * Neither the name of Willow Garage, Inc. nor the names of its
00020  *     contributors may be used to endorse or promote products derived
00021  *     from this software without specific prior written permission.
00022  *
00023  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00024  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00025  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
00026  *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
00027  *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
00028  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
00029  *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
00030  *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
00031  *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
00032  *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
00033  *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00034  *  POSSIBILITY OF SUCH DAMAGE.
00035  *
00036  * $Id: point_cloud_handlers.h 3000 2011-10-31 22:57:26Z rusu $
00037  *
00038  */
00039 #ifndef PCL_POINT_CLOUD_HANDLERS_H_
00040 #define PCL_POINT_CLOUD_HANDLERS_H_
00041 
00042 #include <pcl/visualization/common/common.h>
00043 // PCL includes
00044 #include <pcl/point_types.h>
00045 #include <pcl/point_cloud.h>
00046 #include <pcl/common/io.h>
00047 // VTK includes
00048 #include <vtkSmartPointer.h>
00049 #include <vtkDataArray.h>
00050 #include <vtkUnsignedCharArray.h>
00051 #include <vtkFloatArray.h>
00052 #include <vtkPoints.h>
00053 
00054 namespace pcl
00055 {
00056   namespace visualization
00057   {
00061     template <typename PointT>
00062     class PointCloudGeometryHandler
00063     {
00064       public:
00065         typedef pcl::PointCloud<PointT> PointCloud;
00066         typedef typename PointCloud::Ptr PointCloudPtr;
00067         typedef typename PointCloud::ConstPtr PointCloudConstPtr;
00068 
00069         typedef typename boost::shared_ptr<PointCloudGeometryHandler<PointT> > Ptr;
00070         typedef typename boost::shared_ptr<const PointCloudGeometryHandler<PointT> > ConstPtr;
00071 
00073         PointCloudGeometryHandler (const PointCloudConstPtr &cloud) : 
00074           cloud_ (cloud), capable_ (false)
00075         {}
00076 
00080         virtual std::string 
00081         getName () const = 0;
00082 
00084         virtual std::string 
00085         getFieldName () const  = 0;
00086 
00088         inline bool 
00089         isCapable () const { return (capable_); }
00090 
00094         virtual void 
00095         getGeometry (vtkSmartPointer<vtkPoints> &points) const = 0;
00096 
00097       protected:
00099         PointCloudConstPtr cloud_;
00100 
00104         bool capable_;
00105 
00107         int field_x_idx_;
00108 
00110         int field_y_idx_;
00111 
00113         int field_z_idx_;
00114 
00116         std::vector<sensor_msgs::PointField> fields_;
00117     };
00118 
00120 
00124     template <typename PointT>
00125     class PointCloudGeometryHandlerXYZ : public PointCloudGeometryHandler<PointT>
00126     {
00127       public:
00128         typedef typename PointCloudGeometryHandler<PointT>::PointCloud PointCloud;
00129         typedef typename PointCloud::Ptr PointCloudPtr;
00130         typedef typename PointCloud::ConstPtr PointCloudConstPtr;
00131 
00132         typedef typename boost::shared_ptr<PointCloudGeometryHandlerXYZ<PointT> > Ptr;
00133         typedef typename boost::shared_ptr<const PointCloudGeometryHandlerXYZ<PointT> > ConstPtr;
00134 
00136         PointCloudGeometryHandlerXYZ (const PointCloudConstPtr &cloud);
00137 
00139         virtual inline std::string 
00140         getName () const { return ("PointCloudGeometryHandlerXYZ"); }
00141 
00143         virtual std::string 
00144         getFieldName () const { return ("xyz"); }
00145 
00149         virtual void 
00150         getGeometry (vtkSmartPointer<vtkPoints> &points) const;
00151 
00152       private:
00153         // Members derived from the base class
00154         using PointCloudGeometryHandler<PointT>::cloud_;
00155         using PointCloudGeometryHandler<PointT>::capable_;
00156         using PointCloudGeometryHandler<PointT>::field_x_idx_;
00157         using PointCloudGeometryHandler<PointT>::field_y_idx_;
00158         using PointCloudGeometryHandler<PointT>::field_z_idx_;
00159         using PointCloudGeometryHandler<PointT>::fields_;
00160     };
00161 
00163 
00168     template <typename PointT>
00169     class PointCloudGeometryHandlerSurfaceNormal : public PointCloudGeometryHandler<PointT>
00170     {
00171       public:
00172         typedef typename PointCloudGeometryHandler<PointT>::PointCloud PointCloud;
00173         typedef typename PointCloud::Ptr PointCloudPtr;
00174         typedef typename PointCloud::ConstPtr PointCloudConstPtr;
00175 
00176         typedef typename boost::shared_ptr<PointCloudGeometryHandlerSurfaceNormal<PointT> > Ptr;
00177         typedef typename boost::shared_ptr<const PointCloudGeometryHandlerSurfaceNormal<PointT> > ConstPtr;
00178 
00180         PointCloudGeometryHandlerSurfaceNormal (const PointCloudConstPtr &cloud);
00181 
00183         virtual inline std::string 
00184         getName () const { return ("PointCloudGeometryHandlerSurfaceNormal"); }
00185 
00187         virtual std::string 
00188         getFieldName () const { return ("normal_xyz"); }
00189 
00193         virtual void 
00194         getGeometry (vtkSmartPointer<vtkPoints> &points) const;
00195 
00196       private:
00197         // Members derived from the base class
00198         using PointCloudGeometryHandler<PointT>::cloud_;
00199         using PointCloudGeometryHandler<PointT>::capable_;
00200         using PointCloudGeometryHandler<PointT>::field_x_idx_;
00201         using PointCloudGeometryHandler<PointT>::field_y_idx_;
00202         using PointCloudGeometryHandler<PointT>::field_z_idx_;
00203         using PointCloudGeometryHandler<PointT>::fields_;
00204     };
00205 
00207 
00212     template <typename PointT>
00213     class PointCloudGeometryHandlerCustom : public PointCloudGeometryHandler<PointT>
00214     {
00215       public:
00216         typedef typename PointCloudGeometryHandler<PointT>::PointCloud PointCloud;
00217         typedef typename PointCloud::Ptr PointCloudPtr;
00218         typedef typename PointCloud::ConstPtr PointCloudConstPtr;
00219 
00220         typedef typename boost::shared_ptr<PointCloudGeometryHandlerCustom<PointT> > Ptr;
00221         typedef typename boost::shared_ptr<const PointCloudGeometryHandlerCustom<PointT> > ConstPtr;
00222 
00224         PointCloudGeometryHandlerCustom (const PointCloudConstPtr &cloud, 
00225                                          const std::string &x_field_name, 
00226                                          const std::string &y_field_name, 
00227                                          const std::string &z_field_name);
00228 
00230         virtual inline std::string 
00231         getName () const { return ("PointCloudGeometryHandlerCustom"); }
00232 
00234         virtual std::string 
00235         getFieldName () const { return (field_name_); }
00236 
00240         virtual void 
00241         getGeometry (vtkSmartPointer<vtkPoints> &points) const;
00242 
00243       private:
00244         // Members derived from the base class
00245         using PointCloudGeometryHandler<PointT>::cloud_;
00246         using PointCloudGeometryHandler<PointT>::capable_;
00247         using PointCloudGeometryHandler<PointT>::field_x_idx_;
00248         using PointCloudGeometryHandler<PointT>::field_y_idx_;
00249         using PointCloudGeometryHandler<PointT>::field_z_idx_;
00250         using PointCloudGeometryHandler<PointT>::fields_;
00251 
00253         std::string field_name_;
00254     };
00255 
00257 
00260     template <>
00261     class PCL_EXPORTS PointCloudGeometryHandler<sensor_msgs::PointCloud2>
00262     {
00263       public:
00264         typedef sensor_msgs::PointCloud2 PointCloud;
00265         typedef PointCloud::Ptr PointCloudPtr;
00266         typedef PointCloud::ConstPtr PointCloudConstPtr;
00267 
00268         typedef boost::shared_ptr<PointCloudGeometryHandler<PointCloud> > Ptr;
00269         typedef boost::shared_ptr<const PointCloudGeometryHandler<PointCloud> > ConstPtr;
00270 
00272         PointCloudGeometryHandler (const PointCloudConstPtr &cloud) : 
00273           cloud_ (cloud), capable_ (false)
00274         {
00275           fields_ = cloud_->fields;
00276         }
00277 
00279         virtual std::string 
00280         getName () const = 0;
00281 
00283         virtual std::string 
00284         getFieldName () const  = 0;
00285 
00287         inline bool 
00288         isCapable () const { return (capable_); }
00289 
00293         virtual void 
00294         getGeometry (vtkSmartPointer<vtkPoints> &points) const;
00295 
00296       protected:
00298         PointCloudConstPtr cloud_;
00299 
00303         bool capable_;
00304 
00306         int field_x_idx_;
00307 
00309         int field_y_idx_;
00310 
00312         int field_z_idx_;
00313 
00315         std::vector<sensor_msgs::PointField> fields_;
00316     };
00317 
00319 
00323     template <>
00324     class PCL_EXPORTS PointCloudGeometryHandlerXYZ<sensor_msgs::PointCloud2> : public PointCloudGeometryHandler<sensor_msgs::PointCloud2>
00325     {
00326       public:
00327         typedef PointCloudGeometryHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
00328         typedef PointCloud::Ptr PointCloudPtr;
00329         typedef PointCloud::ConstPtr PointCloudConstPtr;
00330 
00331         typedef boost::shared_ptr<PointCloudGeometryHandlerXYZ<PointCloud> > Ptr;
00332         typedef boost::shared_ptr<const PointCloudGeometryHandlerXYZ<PointCloud> > ConstPtr;
00333 
00335         PointCloudGeometryHandlerXYZ (const PointCloudConstPtr &cloud);
00336 
00338         virtual inline 
00339         std::string getName () const { return ("PointCloudGeometryHandlerXYZ"); }
00340 
00342         virtual std::string 
00343         getFieldName () const { return ("xyz"); }
00344     };
00345 
00347 
00352     template <>
00353     class PCL_EXPORTS PointCloudGeometryHandlerSurfaceNormal<sensor_msgs::PointCloud2> : public PointCloudGeometryHandler<sensor_msgs::PointCloud2>
00354     {
00355       public:
00356         typedef PointCloudGeometryHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
00357         typedef PointCloud::Ptr PointCloudPtr;
00358         typedef PointCloud::ConstPtr PointCloudConstPtr;
00359 
00360         typedef boost::shared_ptr<PointCloudGeometryHandlerSurfaceNormal<PointCloud> > Ptr;
00361         typedef boost::shared_ptr<const PointCloudGeometryHandlerSurfaceNormal<PointCloud> > ConstPtr;
00362 
00364         PointCloudGeometryHandlerSurfaceNormal (const PointCloudConstPtr &cloud);
00365 
00367         virtual inline std::string 
00368         getName () const { return ("PointCloudGeometryHandlerSurfaceNormal"); }
00369 
00371         virtual std::string 
00372         getFieldName () const { return ("normal_xyz"); }
00373     };
00374 
00376 
00381     template <>
00382     class PCL_EXPORTS PointCloudGeometryHandlerCustom<sensor_msgs::PointCloud2> : public PointCloudGeometryHandler<sensor_msgs::PointCloud2>
00383     {
00384       public:
00385         typedef PointCloudGeometryHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
00386         typedef PointCloud::Ptr PointCloudPtr;
00387         typedef PointCloud::ConstPtr PointCloudConstPtr;
00388 
00390         PointCloudGeometryHandlerCustom (const PointCloudConstPtr &cloud, 
00391                                          const std::string &x_field_name, 
00392                                          const std::string &y_field_name, 
00393                                          const std::string &z_field_name);
00394 
00396         virtual inline std::string 
00397         getName () const { return ("PointCloudGeometryHandlerCustom"); }
00398 
00400         virtual std::string 
00401         getFieldName () const { return (field_name_); }
00402 
00403       private:
00405         std::string field_name_;
00406     };
00407 
00409 
00412     template <typename PointT>
00413     class PointCloudColorHandler
00414     {
00415       public:
00416         typedef pcl::PointCloud<PointT> PointCloud;
00417         typedef typename PointCloud::Ptr PointCloudPtr;
00418         typedef typename PointCloud::ConstPtr PointCloudConstPtr;
00419 
00420         typedef boost::shared_ptr<PointCloudColorHandler<PointT> > Ptr;
00421         typedef boost::shared_ptr<const PointCloudColorHandler<PointT> > ConstPtr;
00422 
00424         PointCloudColorHandler (const PointCloudConstPtr &cloud) : 
00425           cloud_ (cloud), capable_ (false)
00426         {}
00427 
00429         inline bool 
00430         isCapable () const { return (capable_); }
00431 
00433         virtual std::string 
00434         getName () const = 0;
00435 
00437         virtual std::string 
00438         getFieldName () const = 0;
00439 
00443         virtual void 
00444         getColor (vtkSmartPointer<vtkDataArray> &scalars) const = 0;
00445 
00446       protected:
00448         PointCloudConstPtr cloud_;
00449 
00453         bool capable_;
00454 
00456         int field_idx_;
00457 
00459         std::vector<sensor_msgs::PointField> fields_;
00460     };
00461    
00463 
00466     template <typename PointT>
00467     class PointCloudColorHandlerRandom : public PointCloudColorHandler<PointT>
00468     {
00469       typedef typename PointCloudColorHandler<PointT>::PointCloud PointCloud;
00470       typedef typename PointCloud::Ptr PointCloudPtr;
00471       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
00472 
00473       public:
00474         typedef boost::shared_ptr<PointCloudColorHandlerRandom<PointT> > Ptr;
00475         typedef boost::shared_ptr<const PointCloudColorHandlerRandom<PointT> > ConstPtr;
00476 
00478         PointCloudColorHandlerRandom (const PointCloudConstPtr &cloud) : 
00479           PointCloudColorHandler<PointT> (cloud) 
00480         { 
00481           capable_ = true; 
00482         }
00483 
00485         virtual inline std::string 
00486         getName () const { return ("PointCloudColorHandlerRandom"); }
00487 
00489         virtual std::string 
00490         getFieldName () const { return ("[random]"); }
00491 
00495         virtual void 
00496         getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
00497 
00498       protected:
00499         // Members derived from the base class
00500         using PointCloudColorHandler<PointT>::cloud_;
00501         using PointCloudColorHandler<PointT>::capable_;
00502     };
00503 
00505 
00509     template <typename PointT>
00510     class PointCloudColorHandlerCustom : public PointCloudColorHandler<PointT>
00511     {
00512       typedef typename PointCloudColorHandler<PointT>::PointCloud PointCloud;
00513       typedef typename PointCloud::Ptr PointCloudPtr;
00514       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
00515 
00516       public:
00517         typedef boost::shared_ptr<PointCloudColorHandlerCustom<PointT> > Ptr;
00518         typedef boost::shared_ptr<const PointCloudColorHandlerCustom<PointT> > ConstPtr;
00519 
00521         PointCloudColorHandlerCustom (const PointCloudConstPtr &cloud, 
00522                                       double r, double g, double b) 
00523           : PointCloudColorHandler<PointT> (cloud)
00524         { 
00525           capable_ = true; 
00526           r_ = r;
00527           g_ = g;
00528           b_ = b;
00529         }
00530 
00532         virtual inline std::string 
00533         getName () const { return ("PointCloudColorHandlerCustom"); }
00534 
00536         virtual std::string 
00537         getFieldName () const { return (""); }
00538 
00542         virtual void 
00543         getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
00544 
00545       protected:
00546         // Members derived from the base class
00547         using PointCloudColorHandler<PointT>::cloud_;
00548         using PointCloudColorHandler<PointT>::capable_;
00549 
00551         double r_, g_, b_;
00552     };
00553 
00555 
00559     template <typename PointT>
00560     class PointCloudColorHandlerRGBField : public PointCloudColorHandler<PointT>
00561     {
00562       typedef typename PointCloudColorHandler<PointT>::PointCloud PointCloud;
00563       typedef typename PointCloud::Ptr PointCloudPtr;
00564       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
00565 
00566       public:
00567         typedef boost::shared_ptr<PointCloudColorHandlerRGBField<PointT> > Ptr;
00568         typedef boost::shared_ptr<const PointCloudColorHandlerRGBField<PointT> > ConstPtr;
00569 
00571         PointCloudColorHandlerRGBField (const PointCloudConstPtr &cloud);
00572 
00574         virtual std::string 
00575         getFieldName () const { return ("rgb"); }
00576 
00580         virtual void 
00581         getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
00582 
00583       protected:
00585         virtual inline std::string 
00586         getName () const { return ("PointCloudColorHandlerRGBField"); }
00587 
00588       private:
00589         // Members derived from the base class
00590         using PointCloudColorHandler<PointT>::cloud_;
00591         using PointCloudColorHandler<PointT>::capable_;
00592         using PointCloudColorHandler<PointT>::field_idx_;
00593         using PointCloudColorHandler<PointT>::fields_;
00594     };
00595 
00597 
00601     template <typename PointT>
00602     class PointCloudColorHandlerGenericField : public PointCloudColorHandler<PointT>
00603     {
00604       typedef typename PointCloudColorHandler<PointT>::PointCloud PointCloud;
00605       typedef typename PointCloud::Ptr PointCloudPtr;
00606       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
00607 
00608       public:
00609         typedef boost::shared_ptr<PointCloudColorHandlerGenericField<PointT> > Ptr;
00610         typedef boost::shared_ptr<const PointCloudColorHandlerGenericField<PointT> > ConstPtr;
00611 
00613         PointCloudColorHandlerGenericField (const PointCloudConstPtr &cloud, 
00614                                             const std::string &field_name);
00615 
00617         virtual std::string getFieldName () const { return (field_name_); }
00618 
00622         virtual void 
00623         getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
00624 
00625       protected:
00627         virtual inline std::string 
00628         getName () const { return ("PointCloudColorHandlerGenericField"); }
00629 
00630       private:
00631         using PointCloudColorHandler<PointT>::cloud_;
00632         using PointCloudColorHandler<PointT>::capable_;
00633         using PointCloudColorHandler<PointT>::field_idx_;
00634         using PointCloudColorHandler<PointT>::fields_;
00635 
00637         std::string field_name_;
00638     };
00639 
00641 
00644     template <>
00645     class PCL_EXPORTS PointCloudColorHandler<sensor_msgs::PointCloud2>
00646     {
00647       public:
00648         typedef sensor_msgs::PointCloud2 PointCloud;
00649         typedef PointCloud::Ptr PointCloudPtr;
00650         typedef PointCloud::ConstPtr PointCloudConstPtr;
00651         
00652         typedef boost::shared_ptr<PointCloudColorHandler<PointCloud> > Ptr;
00653         typedef boost::shared_ptr<const PointCloudColorHandler<PointCloud> > ConstPtr;
00654 
00656         PointCloudColorHandler (const PointCloudConstPtr &cloud) : 
00657           cloud_ (cloud), capable_ (false)
00658         {}
00659 
00661         inline bool 
00662         isCapable () const { return (capable_); }
00663 
00665         virtual std::string 
00666         getName () const = 0;
00667 
00669         virtual std::string 
00670         getFieldName () const = 0;
00671 
00675         virtual void 
00676         getColor (vtkSmartPointer<vtkDataArray> &scalars) const = 0;
00677 
00678       protected:
00680         PointCloudConstPtr cloud_;
00681 
00685         bool capable_;
00686 
00688         int field_idx_;
00689     };
00690 
00692 
00695     template <>
00696     class PCL_EXPORTS PointCloudColorHandlerRandom<sensor_msgs::PointCloud2> : public PointCloudColorHandler<sensor_msgs::PointCloud2>
00697     {
00698       typedef PointCloudColorHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
00699       typedef PointCloud::Ptr PointCloudPtr;
00700       typedef PointCloud::ConstPtr PointCloudConstPtr;
00701 
00702       public:
00703         typedef boost::shared_ptr<PointCloudColorHandlerRandom<PointCloud> > Ptr;
00704         typedef boost::shared_ptr<const PointCloudColorHandlerRandom<PointCloud> > ConstPtr;
00705 
00707         PointCloudColorHandlerRandom (const PointCloudConstPtr &cloud) : 
00708           PointCloudColorHandler<sensor_msgs::PointCloud2> (cloud) 
00709         { 
00710           capable_ = true; 
00711         }
00712 
00714         virtual inline std::string 
00715         getName () const { return ("PointCloudColorHandlerRandom"); }
00716 
00718         virtual std::string 
00719         getFieldName () const { return ("[random]"); }
00720 
00724         virtual void 
00725         getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
00726     };
00727 
00729 
00733     template <>
00734     class PCL_EXPORTS PointCloudColorHandlerCustom<sensor_msgs::PointCloud2> : public PointCloudColorHandler<sensor_msgs::PointCloud2>
00735     {
00736       typedef PointCloudColorHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
00737       typedef PointCloud::Ptr PointCloudPtr;
00738       typedef PointCloud::ConstPtr PointCloudConstPtr;
00739 
00740       public:
00742         PointCloudColorHandlerCustom (const PointCloudConstPtr &cloud, 
00743                                       double r, double g, double b) : 
00744           PointCloudColorHandler<sensor_msgs::PointCloud2> (cloud)
00745         { 
00746           capable_ = true; 
00747           r_ = r;
00748           g_ = g;
00749           b_ = b;
00750         }
00751 
00753         virtual inline std::string 
00754         getName () const { return ("PointCloudColorHandlerCustom"); }
00755 
00757         virtual std::string 
00758         getFieldName () const { return (""); }
00759 
00763         virtual void 
00764         getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
00765 
00766       protected:
00768         double r_, g_, b_;
00769     };
00770 
00772 
00776     template <>
00777     class PCL_EXPORTS PointCloudColorHandlerRGBField<sensor_msgs::PointCloud2> : public PointCloudColorHandler<sensor_msgs::PointCloud2>
00778     {
00779       typedef PointCloudColorHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
00780       typedef PointCloud::Ptr PointCloudPtr;
00781       typedef PointCloud::ConstPtr PointCloudConstPtr;
00782 
00783       public:
00784         typedef boost::shared_ptr<PointCloudColorHandlerRGBField<PointCloud> > Ptr;
00785         typedef boost::shared_ptr<const PointCloudColorHandlerRGBField<PointCloud> > ConstPtr;
00786 
00788         PointCloudColorHandlerRGBField (const PointCloudConstPtr &cloud);
00789 
00793         virtual void 
00794         getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
00795 
00796       protected:
00798         virtual inline std::string 
00799         getName () const { return ("PointCloudColorHandlerRGBField"); }
00800 
00802         virtual std::string 
00803         getFieldName () const { return ("rgb"); }
00804     };
00805 
00807 
00811     template <>
00812     class PCL_EXPORTS PointCloudColorHandlerGenericField<sensor_msgs::PointCloud2> : public PointCloudColorHandler<sensor_msgs::PointCloud2>
00813     {
00814       typedef PointCloudColorHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
00815       typedef PointCloud::Ptr PointCloudPtr;
00816       typedef PointCloud::ConstPtr PointCloudConstPtr;
00817 
00818       public:
00819         typedef boost::shared_ptr<PointCloudColorHandlerGenericField<PointCloud> > Ptr;
00820         typedef boost::shared_ptr<const PointCloudColorHandlerGenericField<PointCloud> > ConstPtr;
00821 
00823         PointCloudColorHandlerGenericField (const PointCloudConstPtr &cloud, 
00824                                             const std::string &field_name);
00825 
00829         virtual void 
00830         getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
00831 
00832       protected:
00834         virtual inline std::string 
00835         getName () const { return ("PointCloudColorHandlerGenericField"); }
00836 
00838         virtual std::string 
00839         getFieldName () const { return (field_name_); }
00840 
00841       private:
00843         std::string field_name_;
00844     };
00845 
00846   }
00847 }
00848 
00849 #include "pcl/visualization/impl/point_cloud_handlers.hpp"
00850 
00851 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines