octree_pointcloud_adjacency_container.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 *  Point Cloud Library (PCL) - www.pointclouds.org
 *  Copyright (c) 2012, Jeremie Papon
 *
 *  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.
 *
 *  Author : jpapon@gmail.com
 *  Email  : jpapon@gmail.com
 */

#ifndef PCL_OCTREE_POINTCLOUD_ADJACENCY_CONTAINER_H_
#define PCL_OCTREE_POINTCLOUD_ADJACENCY_CONTAINER_H_

namespace pcl
{ 
  
  namespace octree
  {
    template<typename PointInT, typename DataT = PointInT>
    class OctreePointCloudAdjacencyContainer : public OctreeContainerBase
    {
    public:
      typedef std::set<OctreePointCloudAdjacencyContainer*> NeighborSetT;
      //iterators to neighbors
      typedef typename NeighborSetT::iterator iterator;
      typedef typename NeighborSetT::const_iterator const_iterator;
      inline iterator begin () { return (neighbors_.begin ()); }
      inline iterator end ()   { return (neighbors_.end ()); }
      inline const_iterator begin () const { return (neighbors_.begin ()); }
      inline const_iterator end () const  { return (neighbors_.end ()); }
      //size of neighbors
      inline size_t size () const { return neighbors_.size (); }
      //insert for neighbors
      inline std::pair<iterator, bool> insert (OctreePointCloudAdjacencyContainer* neighbor) { return neighbors_.insert (neighbor); }
      
      OctreePointCloudAdjacencyContainer () :
      OctreeContainerBase ()
      {
        this->reset();       
      }
      
      virtual ~OctreePointCloudAdjacencyContainer ()
      {
      }
      
      virtual OctreePointCloudAdjacencyContainer *
      deepCopy () const
      {
        OctreePointCloudAdjacencyContainer *new_container = new OctreePointCloudAdjacencyContainer;
        new_container->setNeighbors (this->neighbors_);
        new_container->setPointCounter (this->num_points_);
        return new_container;
      }
      
      void 
      addPoint (const PointInT& new_point)
      {
        using namespace pcl::common;
        ++num_points_;
      }
      
      void
      computeData ()
      {
      }
      
      int
      getPointCounter () const { return num_points_; }
      
      void
      setPointCounter (int points_arg) { num_points_ = points_arg; }
      
      virtual void 
      reset ()
      {
        neighbors_.clear ();
        num_points_ = 0;
        data_ = DataT ();
      }
      
      void 
      addNeighbor (OctreePointCloudAdjacencyContainer *neighbor)
      {
        neighbors_.insert (neighbor);
      }
      
      void 
      removeNeighbor (OctreePointCloudAdjacencyContainer *neighbor)
      {
        neighbors_.erase (neighbor);
        
      }
      
      size_t 
      getNumNeighbors () const
      {
        return neighbors_.size ();
      }
      
      void
      setNeighbors (const NeighborSetT &neighbor_arg)
      {
        neighbors_ = neighbor_arg;
      }
      
      DataT&
      getData () { return data_; }
      
      void
      setData (const DataT& data_arg) { data_ = data_arg;}
      
      virtual size_t
      getSize ()
      {
        return num_points_;
      }
      
      
    private:
      int num_points_;
      NeighborSetT neighbors_;
      DataT data_;
    };
  }
}

#endif