mesh_indices.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 * Point Cloud Library (PCL) - www.pointclouds.org
 * Copyright (c) 2009-2012, Willow Garage, Inc.
 * Copyright (c) 2012-, Open Perception, 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 the copyright holder(s) 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$
 *
 */

// NOTE: This file has been created with 'pcl_src/geometry/include/pcl/geometry/mesh_indices.py'

#ifndef PCL_GEOMETRY_MESH_INDICES_H
#define PCL_GEOMETRY_MESH_INDICES_H

#include <iostream>

#include <pcl/geometry/boost.h>

// VertexIndex

namespace pcl
{
  namespace geometry
  {
    class VertexIndex
        : boost::totally_ordered <pcl::geometry::VertexIndex // < > <= >= == !=
        , boost::unit_steppable  <pcl::geometry::VertexIndex // ++ -- (pre and post)
        , boost::additive        <pcl::geometry::VertexIndex // += + -= -
        > > >
    {
      public:

        typedef boost::totally_ordered <pcl::geometry::VertexIndex,
                boost::unit_steppable  <pcl::geometry::VertexIndex,
                boost::additive        <pcl::geometry::VertexIndex> > > Base;
        typedef pcl::geometry::VertexIndex                              Self;

        VertexIndex ()
          : index_ (-1)
        {
        }

        explicit VertexIndex (const int index)
          : index_ (index)
        {
        }

        inline bool
        isValid () const
        {
          return (index_ >= 0);
        }

        inline void
        invalidate ()
        {
          index_ = -1;
        }

        inline int
        get () const
        {
          return (index_);
        }

        inline void
        set (const int index)
        {
          index_ = index;
        }

        inline bool
        operator < (const Self& other) const
        {
          return (this->get () < other.get ());
        }

        inline bool
        operator == (const Self& other) const
        {
          return (this->get () == other.get ());
        }

        inline Self&
        operator ++ ()
        {
          ++index_;
          return (*this);
        }

        inline Self&
        operator -- ()
        {
          --index_;
          return (*this);
        }

        inline Self&
        operator += (const Self& other)
        {
          index_ += other.get ();
          return (*this);
        }

        inline Self&
        operator -= (const Self& other)
        {
          index_ -= other.get ();
          return (*this);
        }

      private:

        int index_;

        friend std::istream&
        operator >> (std::istream& is, pcl::geometry::VertexIndex& index);
    };

    inline std::ostream&
    operator << (std::ostream& os, const pcl::geometry::VertexIndex& index)
    {
      return (os << index.get ());
    }

    inline std::istream&
    operator >> (std::istream& is, pcl::geometry::VertexIndex& index)
    {
      return (is >> index.index_);
    }

  } // End namespace geometry
} // End namespace pcl

// HalfEdgeIndex

namespace pcl
{
  namespace geometry
  {
    class HalfEdgeIndex
        : boost::totally_ordered <pcl::geometry::HalfEdgeIndex // < > <= >= == !=
        , boost::unit_steppable  <pcl::geometry::HalfEdgeIndex // ++ -- (pre and post)
        , boost::additive        <pcl::geometry::HalfEdgeIndex // += + -= -
        > > >
    {
      public:

        typedef boost::totally_ordered <pcl::geometry::HalfEdgeIndex,
                boost::unit_steppable  <pcl::geometry::HalfEdgeIndex,
                boost::additive        <pcl::geometry::HalfEdgeIndex> > > Base;
        typedef pcl::geometry::HalfEdgeIndex                              Self;

        HalfEdgeIndex ()
          : index_ (-1)
        {
        }

        explicit HalfEdgeIndex (const int index)
          : index_ (index)
        {
        }

        inline bool
        isValid () const
        {
          return (index_ >= 0);
        }

        inline void
        invalidate ()
        {
          index_ = -1;
        }

        inline int
        get () const
        {
          return (index_);
        }

        inline void
        set (const int index)
        {
          index_ = index;
        }

        inline bool
        operator < (const Self& other) const
        {
          return (this->get () < other.get ());
        }

        inline bool
        operator == (const Self& other) const
        {
          return (this->get () == other.get ());
        }

        inline Self&
        operator ++ ()
        {
          ++index_;
          return (*this);
        }

        inline Self&
        operator -- ()
        {
          --index_;
          return (*this);
        }

        inline Self&
        operator += (const Self& other)
        {
          index_ += other.get ();
          return (*this);
        }

        inline Self&
        operator -= (const Self& other)
        {
          index_ -= other.get ();
          return (*this);
        }

      private:

        int index_;

        friend std::istream&
        operator >> (std::istream& is, pcl::geometry::HalfEdgeIndex& index);
    };

    inline std::ostream&
    operator << (std::ostream& os, const pcl::geometry::HalfEdgeIndex& index)
    {
      return (os << index.get ());
    }

    inline std::istream&
    operator >> (std::istream& is, pcl::geometry::HalfEdgeIndex& index)
    {
      return (is >> index.index_);
    }

  } // End namespace geometry
} // End namespace pcl

// EdgeIndex

namespace pcl
{
  namespace geometry
  {
    class EdgeIndex
        : boost::totally_ordered <pcl::geometry::EdgeIndex // < > <= >= == !=
        , boost::unit_steppable  <pcl::geometry::EdgeIndex // ++ -- (pre and post)
        , boost::additive        <pcl::geometry::EdgeIndex // += + -= -
        > > >
    {
      public:

        typedef boost::totally_ordered <pcl::geometry::EdgeIndex,
                boost::unit_steppable  <pcl::geometry::EdgeIndex,
                boost::additive        <pcl::geometry::EdgeIndex> > > Base;
        typedef pcl::geometry::EdgeIndex                              Self;

        EdgeIndex ()
          : index_ (-1)
        {
        }

        explicit EdgeIndex (const int index)
          : index_ (index)
        {
        }

        inline bool
        isValid () const
        {
          return (index_ >= 0);
        }

        inline void
        invalidate ()
        {
          index_ = -1;
        }

        inline int
        get () const
        {
          return (index_);
        }

        inline void
        set (const int index)
        {
          index_ = index;
        }

        inline bool
        operator < (const Self& other) const
        {
          return (this->get () < other.get ());
        }

        inline bool
        operator == (const Self& other) const
        {
          return (this->get () == other.get ());
        }

        inline Self&
        operator ++ ()
        {
          ++index_;
          return (*this);
        }

        inline Self&
        operator -- ()
        {
          --index_;
          return (*this);
        }

        inline Self&
        operator += (const Self& other)
        {
          index_ += other.get ();
          return (*this);
        }

        inline Self&
        operator -= (const Self& other)
        {
          index_ -= other.get ();
          return (*this);
        }

      private:

        int index_;

        friend std::istream&
        operator >> (std::istream& is, pcl::geometry::EdgeIndex& index);
    };

    inline std::ostream&
    operator << (std::ostream& os, const pcl::geometry::EdgeIndex& index)
    {
      return (os << index.get ());
    }

    inline std::istream&
    operator >> (std::istream& is, pcl::geometry::EdgeIndex& index)
    {
      return (is >> index.index_);
    }

  } // End namespace geometry
} // End namespace pcl

// FaceIndex

namespace pcl
{
  namespace geometry
  {
    class FaceIndex
        : boost::totally_ordered <pcl::geometry::FaceIndex // < > <= >= == !=
        , boost::unit_steppable  <pcl::geometry::FaceIndex // ++ -- (pre and post)
        , boost::additive        <pcl::geometry::FaceIndex // += + -= -
        > > >
    {
      public:

        typedef boost::totally_ordered <pcl::geometry::FaceIndex,
                boost::unit_steppable  <pcl::geometry::FaceIndex,
                boost::additive        <pcl::geometry::FaceIndex> > > Base;
        typedef pcl::geometry::FaceIndex                              Self;

        FaceIndex ()
          : index_ (-1)
        {
        }

        explicit FaceIndex (const int index)
          : index_ (index)
        {
        }

        inline bool
        isValid () const
        {
          return (index_ >= 0);
        }

        inline void
        invalidate ()
        {
          index_ = -1;
        }

        inline int
        get () const
        {
          return (index_);
        }

        inline void
        set (const int index)
        {
          index_ = index;
        }

        inline bool
        operator < (const Self& other) const
        {
          return (this->get () < other.get ());
        }

        inline bool
        operator == (const Self& other) const
        {
          return (this->get () == other.get ());
        }

        inline Self&
        operator ++ ()
        {
          ++index_;
          return (*this);
        }

        inline Self&
        operator -- ()
        {
          --index_;
          return (*this);
        }

        inline Self&
        operator += (const Self& other)
        {
          index_ += other.get ();
          return (*this);
        }

        inline Self&
        operator -= (const Self& other)
        {
          index_ -= other.get ();
          return (*this);
        }

      private:

        int index_;

        friend std::istream&
        operator >> (std::istream& is, pcl::geometry::FaceIndex& index);
    };

    inline std::ostream&
    operator << (std::ostream& os, const pcl::geometry::FaceIndex& index)
    {
      return (os << index.get ());
    }

    inline std::istream&
    operator >> (std::istream& is, pcl::geometry::FaceIndex& index)
    {
      return (is >> index.index_);
    }

  } // End namespace geometry
} // End namespace pcl

// Conversions

namespace pcl
{
  namespace geometry
  {
    inline pcl::geometry::EdgeIndex
    toEdgeIndex (const HalfEdgeIndex& index)
    {
      return (index.isValid () ? EdgeIndex (index.get () / 2) : EdgeIndex ());
    }

    inline pcl::geometry::HalfEdgeIndex
    toHalfEdgeIndex (const EdgeIndex& index, const bool get_first=true)
    {
      return (index.isValid () ? HalfEdgeIndex (index.get () * 2 + static_cast <int> (!get_first)) : HalfEdgeIndex ());
    }
  } // End namespace geometry
} // End namespace pcl

#endif // PCL_GEOMETRY_MESH_INDICES_H