octree_nodes.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$
 */

#ifndef PCL_OCTREE_NODE_H
#define PCL_OCTREE_NODE_H

#include <cstddef>

#include <assert.h>
#include <cstring>

#include <string.h>

#include <pcl/pcl_macros.h>

#include "octree_container.h"

namespace pcl
{
  namespace octree
  {

    // enum of node types within the octree
    enum node_type_t
    {
      BRANCH_NODE, LEAF_NODE
    };


    class PCL_EXPORTS OctreeNode
    {
    public:

      OctreeNode ()
      {
      }

      virtual
      ~OctreeNode ()
      {
      }
      virtual node_type_t
      getNodeType () const = 0;

      virtual OctreeNode*
      deepCopy () const = 0;

    };


    template<typename ContainerT>
      class OctreeLeafNode : public OctreeNode
      {
      public:

        OctreeLeafNode () :
            OctreeNode ()
        {
        }

        OctreeLeafNode (const OctreeLeafNode& source) :
            OctreeNode ()
        {
          container_ = source.container_;
        }

        virtual
        ~OctreeLeafNode ()
        {
        }

        virtual OctreeLeafNode<ContainerT>*
        deepCopy () const
        {
          return new OctreeLeafNode<ContainerT> (*this);
        }

        virtual node_type_t
        getNodeType () const
        {
          return LEAF_NODE;
        }

        const ContainerT*
        operator->() const
        {
          return &container_;
        }

        ContainerT*
        operator-> ()
        {
          return &container_;
        }

        const ContainerT&
        operator* () const
        {
          return container_;
        }

        ContainerT&
        operator* ()
        {
          return container_;
        }

        const ContainerT&
        getContainer () const
        {
          return container_;
        }

        ContainerT&
        getContainer ()
        {
          return container_;
        }

        const ContainerT*
        getContainerPtr() const
        {
          return &container_;
        }

        ContainerT*
        getContainerPtr ()
        {
          return &container_;
        }

      protected:
        ContainerT container_;
      };


    template<typename ContainerT>
      class OctreeBranchNode : public OctreeNode
      {
      public:

        OctreeBranchNode () :
            OctreeNode()
        {
          // reset pointer to child node vectors
          memset (child_node_array_, 0, sizeof(child_node_array_));
        }

        OctreeBranchNode (const OctreeBranchNode& source) :
            OctreeNode()
        {
          unsigned char i;

          memset (child_node_array_, 0, sizeof(child_node_array_));

          for (i = 0; i < 8; ++i)
            if (source.child_node_array_[i])
              child_node_array_[i] = source.child_node_array_[i]->deepCopy ();
        }

        inline OctreeBranchNode&
        operator = (const OctreeBranchNode &source)
        {
          unsigned char i;

          memset (child_node_array_, 0, sizeof(child_node_array_));

          for (i = 0; i < 8; ++i)
            if (source.child_node_array_[i])
              child_node_array_[i] = source.child_node_array_[i]->deepCopy ();
          return (*this);
        }

        virtual OctreeBranchNode*
        deepCopy () const
        {
          return (new OctreeBranchNode<ContainerT> (*this));
        }

        virtual
        ~OctreeBranchNode ()
        {
        }

        inline OctreeNode*&
        operator[] (unsigned char child_idx_arg)
        {
          assert(child_idx_arg < 8);
          return child_node_array_[child_idx_arg];
        }

        inline OctreeNode*
        getChildPtr (unsigned char child_idx_arg) const
        {
          assert(child_idx_arg < 8);
          return child_node_array_[child_idx_arg];
        }

        inline void setChildPtr (OctreeNode* child, unsigned char index)
        {
          assert(index < 8);
          child_node_array_[index] = child;
        }


        inline bool hasChild (unsigned char child_idx_arg) const
        {
          return (child_node_array_[child_idx_arg] != 0);
        }


    /*    inline bool isPrunable () const
        {
          const OctreeNode* firstChild = child_node_array_[0];
          if (!firstChild || firstChild->getNodeType()==BRANCH_NODE)
            return false;

          bool prunable = true;
          for (unsigned char i = 1; i < 8 && prunable; ++i)
          {
            const OctreeNode* child = child_node_array_[i];
            if ( (!child) ||
                 (child->getNodeType()==BRANCH_NODE) ||
                 ((*static_cast<const OctreeContainerBase*>(child)) == (*static_cast<const OctreeContainerBase*>(child)) ) )
              prunable = false;
          }

          return prunable;
        }*/

        virtual node_type_t
        getNodeType () const
        {
          return BRANCH_NODE;
        }

        // reset node
        void reset()
        {
          memset(child_node_array_, 0, sizeof(child_node_array_));
          container_.reset();
        }


        const ContainerT*
        operator->() const
        {
          return &container_;
        }

        ContainerT*
        operator-> ()
        {
          return &container_;
        }

        const ContainerT&
        operator* () const
        {
          return container_;
        }

        ContainerT&
        operator* ()
        {
          return container_;
        }

        const ContainerT&
        getContainer () const
        {
          return container_;
        }

        ContainerT&
        getContainer ()
        {
          return container_;
        }

        const ContainerT*
        getContainerPtr() const
        {
          return &container_;
        }

        ContainerT*
        getContainerPtr ()
        {
          return &container_;
        }

      protected:
        OctreeNode* child_node_array_[8];

        ContainerT container_;
      };
  }
}

#endif