point_cloud.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 *  Point Cloud Library (PCL) - www.pointclouds.org
 *  Copyright (c) 2010-2012, 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: point_cloud.h 6126 2012-07-03 20:19:58Z aichim $
 *
 */

#ifndef PCL_POINT_CLOUD_H_
#define PCL_POINT_CLOUD_H_

#include <pcl/common/eigen.h>
#include <cstddef>
#include <std_msgs/Header.h>
#include <pcl/pcl_macros.h>
#include <pcl/exceptions.h>
#include <pcl/cloud_properties.h>
#include <pcl/channel_properties.h>
#include <pcl/point_traits.h>
#include <pcl/for_each_type.h>
#include <boost/shared_ptr.hpp>
#include <map>
#include <boost/mpl/size.hpp>

namespace pcl
{
  namespace detail
  {
    struct FieldMapping
    {
      size_t serialized_offset;
      size_t struct_offset;
      size_t size;
    };
  } // namespace detail

  // Forward declarations
  template <typename PointT> class PointCloud;
  typedef std::vector<detail::FieldMapping> MsgFieldMap;
 

  template <typename PointOutT>
  struct NdCopyEigenPointFunctor
  {
    typedef typename traits::POD<PointOutT>::type Pod;
    
    NdCopyEigenPointFunctor (const Eigen::VectorXf &p1, PointOutT &p2)
      : p1_ (p1),
        p2_ (reinterpret_cast<Pod&>(p2)),
        f_idx_ (0) { }

    template<typename Key> inline void 
    operator() ()
    {
      //boost::fusion::at_key<Key> (p2_) = p1_[f_idx_++];
      typedef typename pcl::traits::datatype<PointOutT, Key>::type T;
      uint8_t* data_ptr = reinterpret_cast<uint8_t*>(&p2_) + pcl::traits::offset<PointOutT, Key>::value;
      *reinterpret_cast<T*>(data_ptr) = static_cast<T> (p1_[f_idx_++]);
    }

    private:
      const Eigen::VectorXf &p1_;
      Pod &p2_;
      int f_idx_;
    public:
      EIGEN_MAKE_ALIGNED_OPERATOR_NEW
   };


  template <typename PointInT>
  struct NdCopyPointEigenFunctor
  {
    typedef typename traits::POD<PointInT>::type Pod;
    
     NdCopyPointEigenFunctor (const PointInT &p1, Eigen::VectorXf &p2)
      : p1_ (reinterpret_cast<const Pod&>(p1)), p2_ (p2), f_idx_ (0) { }

    template<typename Key> inline void 
    operator() ()
    {
      //p2_[f_idx_++] = boost::fusion::at_key<Key> (p1_);
      typedef typename pcl::traits::datatype<PointInT, Key>::type T;
      const uint8_t* data_ptr = reinterpret_cast<const uint8_t*>(&p1_) + pcl::traits::offset<PointInT, Key>::value;
      p2_[f_idx_++] = static_cast<float> (*reinterpret_cast<const T*>(data_ptr));
    }

    private:
      const Pod &p1_;
      Eigen::VectorXf &p2_;
      int f_idx_;
    public:
      EIGEN_MAKE_ALIGNED_OPERATOR_NEW
  };

  namespace detail
  {
    template <typename PointT> boost::shared_ptr<pcl::MsgFieldMap>&
    getMapping (pcl::PointCloud<PointT>& p);
  } // namespace detail

  template <typename PointT>
  class PointCloud
  {
    public:
      PointCloud () : 
        header (), points (), width (0), height (0), is_dense (true),
        sensor_origin_ (Eigen::Vector4f::Zero ()), sensor_orientation_ (Eigen::Quaternionf::Identity ()),
        mapping_ ()
      {}

      PointCloud (PointCloud<PointT> &pc) : 
        header (), points (), width (0), height (0), is_dense (true), 
        sensor_origin_ (Eigen::Vector4f::Zero ()), sensor_orientation_ (Eigen::Quaternionf::Identity ()),
        mapping_ ()
      {
        *this = pc;
      }

      PointCloud (const PointCloud<PointT> &pc) : 
        header (), points (), width (0), height (0), is_dense (true), 
        sensor_origin_ (Eigen::Vector4f::Zero ()), sensor_orientation_ (Eigen::Quaternionf::Identity ()),
        mapping_ ()
      {
        *this = pc;
      }

      PointCloud (const PointCloud<PointT> &pc, 
                  const std::vector<int> &indices) :
        header (pc.header), points (indices.size ()), width (indices.size ()), height (1), is_dense (pc.is_dense),
        sensor_origin_ (pc.sensor_origin_), sensor_orientation_ (pc.sensor_orientation_),
        mapping_ ()
      {
        // Copy the obvious
        assert (indices.size () <= pc.size ());
        for (size_t i = 0; i < indices.size (); i++)
          points[i] = pc.points[indices[i]];
      }

      PointCloud (uint32_t width_, uint32_t height_, const PointT& value_ = PointT ())
        : header ()
        , points (width_ * height_, value_)
        , width (width_)
        , height (height_)
        , is_dense (true)
        , sensor_origin_ (Eigen::Vector4f::Zero ())
        , sensor_orientation_ (Eigen::Quaternionf::Identity ())
        , mapping_ ()
      {}

      virtual ~PointCloud () {}


      inline PointCloud&
      operator += (const PointCloud& rhs)
      {
        // Make the resultant point cloud take the newest stamp
        if (rhs.header.stamp > header.stamp)
          header.stamp = rhs.header.stamp;

        size_t nr_points = points.size ();
        points.resize (nr_points + rhs.points.size ());
        for (size_t i = nr_points; i < points.size (); ++i)
          points[i] = rhs.points[i - nr_points];

        width    = static_cast<uint32_t>(points.size ());
        height   = 1;
        if (rhs.is_dense && is_dense)
          is_dense = true;
        else
          is_dense = false;
        return (*this);
      }


      inline const PointCloud
      operator + (const PointCloud& rhs)
      {
        return (PointCloud (*this) += rhs);
      }
      

      inline const PointT&
      at (int column, int row) const
      {
        if (this->height > 1)
          return (points.at (row * this->width + column));
        else
          throw IsNotDenseException ("Can't use 2D indexing with a unorganized point cloud");
      }

      inline PointT&
      at (int column, int row)
      {
        if (this->height > 1)
          return (points.at (row * this->width + column));
        else
          throw IsNotDenseException ("Can't use 2D indexing with a unorganized point cloud");
      }


      inline const PointT&
      operator () (size_t column, size_t row) const
      {
        return (points[row * this->width + column]);
      }

      inline PointT&
      operator () (size_t column, size_t row)
      {
        return (points[row * this->width + column]);
      }


      inline bool
      isOrganized () const
      {
        return (height != 1);
      }
      

      inline Eigen::Map<Eigen::MatrixXf, Eigen::Aligned, Eigen::OuterStride<> > 
      getMatrixXfMap (int dim, int stride, int offset)
      {
        if (Eigen::MatrixXf::Flags & Eigen::RowMajorBit)
          return (Eigen::Map<Eigen::MatrixXf, Eigen::Aligned, Eigen::OuterStride<> >(reinterpret_cast<float*>(&points[0])+offset, points.size (), dim, Eigen::OuterStride<> (stride)));
        else
          return (Eigen::Map<Eigen::MatrixXf, Eigen::Aligned, Eigen::OuterStride<> >(reinterpret_cast<float*>(&points[0])+offset, dim, points.size (), Eigen::OuterStride<> (stride)));
      }

      inline const Eigen::Map<const Eigen::MatrixXf, Eigen::Aligned, Eigen::OuterStride<> >
      getMatrixXfMap (int dim, int stride, int offset) const
      {
        if (Eigen::MatrixXf::Flags & Eigen::RowMajorBit)
          return (Eigen::Map<const Eigen::MatrixXf, Eigen::Aligned, Eigen::OuterStride<> >(reinterpret_cast<float*>(&points[0])+offset, points.size (), dim, Eigen::OuterStride<> (stride)));
        else
          return (Eigen::Map<const Eigen::MatrixXf, Eigen::Aligned, Eigen::OuterStride<> >(reinterpret_cast<float*>(&points[0])+offset, dim, points.size (), Eigen::OuterStride<> (stride)));                
      }


      inline Eigen::Map<Eigen::MatrixXf, Eigen::Aligned, Eigen::OuterStride<> >
      getMatrixXfMap () 
      {
        return (getMatrixXfMap (sizeof (PointT) / sizeof (float),  sizeof (PointT) / sizeof (float), 0));
      }

      inline const Eigen::Map<const Eigen::MatrixXf, Eigen::Aligned, Eigen::OuterStride<> >
      getMatrixXfMap () const
      {
        return (getMatrixXfMap (sizeof (PointT) / sizeof (float),  sizeof (PointT) / sizeof (float), 0));
      }

      std_msgs::Header header;

      std::vector<PointT, Eigen::aligned_allocator<PointT> > points;

      uint32_t width;
      uint32_t height;

      bool is_dense;

      Eigen::Vector4f    sensor_origin_;
      Eigen::Quaternionf sensor_orientation_;

      typedef PointT PointType;  // Make the template class available from the outside
      typedef std::vector<PointT, Eigen::aligned_allocator<PointT> > VectorType;
      typedef std::vector<PointCloud<PointT>, Eigen::aligned_allocator<PointCloud<PointT> > > CloudVectorType;
      typedef boost::shared_ptr<PointCloud<PointT> > Ptr;
      typedef boost::shared_ptr<const PointCloud<PointT> > ConstPtr;

      // iterators
      typedef typename VectorType::iterator iterator;
      typedef typename VectorType::const_iterator const_iterator;
      inline iterator begin () { return (points.begin ()); }
      inline iterator end ()   { return (points.end ()); }
      inline const_iterator begin () const { return (points.begin ()); }
      inline const_iterator end () const  { return (points.end ()); }

      //capacity
      inline size_t size () const { return (points.size ()); }
      inline void reserve (size_t n) { points.reserve (n); }
      inline bool empty () const { return points.empty (); }

      inline void resize (size_t n) 
      { 
        points.resize (n);
        if (width * height != n)
        {
          width = static_cast<uint32_t> (n);
          height = 1;
        }
      }

      //element access
      inline const PointT& operator[] (size_t n) const { return (points[n]); }
      inline PointT& operator[] (size_t n) { return (points[n]); }
      inline const PointT& at (size_t n) const { return (points.at (n)); }
      inline PointT& at (size_t n) { return (points.at (n)); }
      inline const PointT& front () const { return (points.front ()); }
      inline PointT& front () { return (points.front ()); }
      inline const PointT& back () const { return (points.back ()); }
      inline PointT& back () { return (points.back ()); }

      inline void 
      push_back (const PointT& pt)
      {
        points.push_back (pt);
        width = static_cast<uint32_t> (points.size ());
        height = 1;
      }

      inline iterator 
      insert (iterator position, const PointT& pt)
      {
        iterator it = points.insert (position, pt);
        width = static_cast<uint32_t> (points.size ());
        height = 1;
        return (it);
      }

      inline void 
      insert (iterator position, size_t n, const PointT& pt)
      {
        points.insert (position, n, pt);
        width = static_cast<uint32_t> (points.size ());
        height = 1;
      }

      template <class InputIterator> inline void 
      insert (iterator position, InputIterator first, InputIterator last)
      {
        points.insert (position, first, last);
        width = static_cast<uint32_t> (points.size ());
        height = 1;
      }

      inline iterator 
      erase (iterator position)
      {
        iterator it = points.erase (position); 
        width = static_cast<uint32_t> (points.size ());
        height = 1;
        return (it);
      }

      inline iterator 
      erase (iterator first, iterator last)
      {
        iterator it = points.erase (first, last);
        width = static_cast<uint32_t> (points.size ());
        height = 1;
        return (it);
      }

      inline void 
      swap (PointCloud<PointT> &rhs)
      {
        this->points.swap (rhs.points);
        std::swap (width, rhs.width);
        std::swap (height, rhs.height);
        std::swap (is_dense, rhs.is_dense);
        std::swap (sensor_origin_, rhs.sensor_origin_);
        std::swap (sensor_orientation_, rhs.sensor_orientation_);
      }

      inline void 
      clear ()
      {
        points.clear ();
        width = 0;
        height = 0;
      }

      inline Ptr 
      makeShared () const { return Ptr (new PointCloud<PointT> (*this)); }

    protected:
      // This is motivated by ROS integration. Users should not need to access mapping_.
      boost::shared_ptr<MsgFieldMap> mapping_;

      friend boost::shared_ptr<MsgFieldMap>& detail::getMapping<PointT>(pcl::PointCloud<PointT> &p);

    public:
      EIGEN_MAKE_ALIGNED_OPERATOR_NEW
  };

  template <>
  class PointCloud<Eigen::MatrixXf> 
  {
    public:
      PointCloud () : 
        properties (), points (Eigen::MatrixXf (0, 0)), channels (), width (0), height (0), is_dense (true)
      {}

      PointCloud (PointCloud<Eigen::MatrixXf> &pc) :
        properties (), points (Eigen::MatrixXf (0, 0)), channels (), width (0), height (0), is_dense (true)
      {
        *this = pc;
      }
 
      template <typename PointT>
      PointCloud (PointCloud<PointT> &pc) :
        properties (), points (Eigen::MatrixXf (0, 0)), channels (), 
        width (pc.width), height (pc.height), is_dense (pc.is_dense)
      {
        // Copy the obvious
        properties.acquisition_time   = pc.header.stamp;
        properties.sensor_origin      = pc.sensor_origin_;//.head<3> ();
        properties.sensor_orientation = pc.sensor_orientation_;

        typedef typename pcl::traits::fieldList<PointT>::type FieldList;
        // Copy the fields
        pcl::for_each_type <FieldList> (CopyFieldsChannelProperties <PointT> (channels));
      
        // Resize the array
        points.resize (pc.points.size (), boost::mpl::size<FieldList>::value);

        for (size_t cp = 0; cp < pc.points.size (); ++cp)
          pcl::for_each_type <FieldList> (NdCopyPointEigenFunctor<PointT, Eigen::MatrixXf::RowXpr> (pc.points[cp], points.row (cp)));
      }
 
      PointCloud (const PointCloud<Eigen::MatrixXf> &pc) :
        properties (), points (Eigen::MatrixXf (0, 0)), channels (), width (0), height (0), is_dense (true)
      {
        *this = pc;
      }

      template <typename PointT>
      PointCloud (const PointCloud<PointT> &pc) :
        properties (), points (Eigen::MatrixXf (0, 0)), channels (), 
        width (pc.width), height (pc.height), is_dense (pc.is_dense)
      {
        // Copy the obvious
        properties.acquisition_time   = pc.header.stamp;
        properties.sensor_origin      = pc.sensor_origin_;//.head<3> ();
        properties.sensor_orientation = pc.sensor_orientation_;

        typedef typename pcl::traits::fieldList<PointT>::type FieldList;

        // Copy the fields
        pcl::for_each_type <FieldList> (CopyFieldsChannelProperties <PointT> (channels));

        // Resize the array
        points.resize (pc.points.size (), boost::mpl::size<FieldList>::value);

        for (size_t cp = 0; cp < pc.points.size (); ++cp)
          pcl::for_each_type <FieldList> (NdCopyPointEigenFunctor<PointT, Eigen::MatrixXf::RowXpr> (pc.points[cp], points.row (cp)));
      }

      PointCloud (const PointCloud &pc, 
                  const std::vector<int> &indices) :
        properties (pc.properties), 
        points (Eigen::MatrixXf (indices.size (), pc.points.cols ())), 
        channels (pc.channels), 
        width (static_cast<uint32_t> (indices.size ())), height (1), is_dense (pc.is_dense)
      {
        // Copy the obvious
        assert (static_cast<int>(indices.size ()) <= pc.points.rows ());
        for (size_t i = 0; i < indices.size (); i++)
          points.row (i) = pc.points.row (indices[i]);
      }

      inline PointCloud (uint32_t _width, uint32_t _height, uint32_t _dim)
        : properties ()
        , points (Eigen::MatrixXf (_width * _height, _dim))
        , channels ()
        , width (_width)
        , height (_height)
        , is_dense (true)
      {}

      inline PointCloud (uint32_t _num_points, uint32_t _dim)
        : properties ()
        , points (Eigen::MatrixXf (_num_points, _dim))
        , channels ()
        , width (_num_points)
        , height (1)
        , is_dense (true)
      {}

      virtual ~PointCloud () {}


      inline PointCloud&
      operator += (const PointCloud& rhs)
      {
        if (rhs.properties.acquisition_time > properties.acquisition_time)
          properties.acquisition_time = rhs.properties.acquisition_time;

        properties.sensor_origin = Eigen::Vector4f::Zero ();
        properties.sensor_orientation = Eigen::Quaternionf::Identity ();

        int nr_points = static_cast<int>(points.rows ());
        points.resize (nr_points + rhs.points.rows (), points.cols ());
        for (int i = nr_points; i < points.rows (); ++i)
          points.row (i) = rhs.points.row (i - nr_points);

        channels = rhs.channels;
        width    = static_cast<uint32_t>(points.rows ());
        height   = 1;
        if (rhs.is_dense && is_dense)
          is_dense = true;
        else
          is_dense = false;
        return (*this);
      }
      

      inline const PointCloud
      operator + (const PointCloud& rhs)
      {
        return (PointCloud (*this) += rhs);
      }


      inline Eigen::Map<Eigen::VectorXf>
      at (int column, int row)
      {
        if (height > 1)
          return (Eigen::VectorXf::Map (&points (row * width + column, 0), points.cols ()));
        else
          throw IsNotDenseException ("Can't use 2D indexing with a unorganized point cloud");
      }


      inline Eigen::Map<Eigen::VectorXf>
      operator () (int column, int row) 
      {
        return (Eigen::VectorXf::Map (&points (row * width + column, 0), points.cols ()));
      }


      inline bool
      isOrganized () const
      {
        return (height != 1);
      }
      

      inline bool 
      empty () const 
      { 
        return (points.rows () == 0); 
      }

      pcl::CloudProperties properties;

      Eigen::MatrixXf points;

      std::map<std::string, pcl::ChannelProperties> channels;

      uint32_t width;
      uint32_t height;

      bool is_dense;

      typedef boost::shared_ptr<PointCloud<Eigen::MatrixXf> > Ptr;
      typedef boost::shared_ptr<const PointCloud<Eigen::MatrixXf> > ConstPtr;

      inline size_t size () const { return (points.rows ()); }

      inline void 
      swap (PointCloud<Eigen::MatrixXf> &rhs)
      {
        std::swap (points, rhs.points);
        std::swap (width, rhs.width);
        std::swap (height, rhs.height);
        std::swap (is_dense, rhs.is_dense);
        std::swap (properties, rhs.properties);
        std::swap (channels, rhs.channels);
      }

      inline void 
      clear ()
      {
        points.resize (0, 0);
        width = 0;
        height = 0;
      }

      inline Ptr 
      makeShared () { return Ptr (new PointCloud<Eigen::MatrixXf> (*this)); }

      inline ConstPtr 
      makeShared () const { return ConstPtr (new PointCloud<Eigen::MatrixXf> (*this)); }

    public:
      EIGEN_MAKE_ALIGNED_OPERATOR_NEW

    private:

      template <typename PointOutT, typename PointInT>
      struct NdCopyEigenPointFunctor
      {
        typedef typename traits::POD<PointOutT>::type Pod;
        
        NdCopyEigenPointFunctor (const PointInT p1, PointOutT &p2)
          : p1_ (p1),
            p2_ (reinterpret_cast<Pod&>(p2)),
            f_idx_ (0) { }

        template<typename Key> inline void 
        operator() ()
        {
          //boost::fusion::at_key<Key> (p2_) = p1_[f_idx_++];
          typedef typename pcl::traits::datatype<PointOutT, Key>::type T;
          uint8_t* data_ptr = reinterpret_cast<uint8_t*>(&p2_) + pcl::traits::offset<PointOutT, Key>::value;
          *reinterpret_cast<T*>(data_ptr) = p1_[f_idx_++];
        }

        private:
          const PointInT p1_;
          Pod &p2_;
          int f_idx_;
        public:
          EIGEN_MAKE_ALIGNED_OPERATOR_NEW
       };


      template <typename PointInT, typename PointOutT>
      struct NdCopyPointEigenFunctor
      {
        typedef typename traits::POD<PointInT>::type Pod;
        
         NdCopyPointEigenFunctor (const PointInT &p1, PointOutT p2)
          : p1_ (reinterpret_cast<const Pod&>(p1)), p2_ (p2), f_idx_ (0) { }

        template<typename Key> inline void 
        operator() ()
        {
          //p2_[f_idx_++] = boost::fusion::at_key<Key> (p1_);
          typedef typename pcl::traits::datatype<PointInT, Key>::type T;
          const uint8_t* data_ptr = reinterpret_cast<const uint8_t*>(&p1_) + pcl::traits::offset<PointInT, Key>::value;
          p2_[f_idx_++] = *reinterpret_cast<const T*>(data_ptr);
        }

        private:
          const Pod &p1_;
          PointOutT p2_;
          int f_idx_;
        public:
          EIGEN_MAKE_ALIGNED_OPERATOR_NEW
      };


      template <typename T>
      struct CopyFieldsChannelProperties
      {
        CopyFieldsChannelProperties (std::map<std::string, pcl::ChannelProperties> &channels)
          : channels_ (channels) {}

        template<typename U> inline void 
        operator() ()
        {
          //boost::fusion::at_key<Key> (p2_) = p1_[f_idx_++];
          std::string name = pcl::traits::name<T, U>::value;
          channels_[name].name     = name;
          channels_[name].offset   = pcl::traits::offset<T, U>::value;
          uint8_t datatype = pcl::traits::datatype<T, U>::value;
          channels_[name].datatype = datatype;
          int count = pcl::traits::datatype<T, U>::size;
          channels_[name].count    = count;
          switch (datatype)
          {
            case sensor_msgs::PointField::INT8:
            case sensor_msgs::PointField::UINT8:
            {
              channels_[name].size = count;
              break;
            }
      
            case sensor_msgs::PointField::INT16:
            case sensor_msgs::PointField::UINT16:
            {
              channels_[name].size = count * 2;
              break;
            }
      
            case sensor_msgs::PointField::INT32:
            case sensor_msgs::PointField::UINT32:
            case sensor_msgs::PointField::FLOAT32:
            {
              channels_[name].size = count * 4;
              break;
            }
      
            case sensor_msgs::PointField::FLOAT64:
            {
              channels_[name].size = count * 8;
              break;
            }
          }
        }

        private:
          std::map<std::string, pcl::ChannelProperties> &channels_;
       };
  };

  namespace detail
  {
    template <typename PointT> boost::shared_ptr<pcl::MsgFieldMap>&
    getMapping (pcl::PointCloud<PointT>& p)
    {
      return (p.mapping_);
    }
  } // namespace detail

  template <typename PointT> std::ostream&
  operator << (std::ostream& s, const pcl::PointCloud<PointT> &p)
  {
    s << "points[]: " << p.points.size () << std::endl;
    s << "width: " << p.width << std::endl;
    s << "height: " << p.height << std::endl;
    s << "is_dense: " << p.is_dense << std::endl;
    return (s);
  }
}

#endif  //#ifndef PCL_POINT_CLOUD_H_