mesh_circulators.h
/*
* 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_circulators.py'
#ifndef PCL_GEOMETRY_MESH_CIRCULATORS_H
#define PCL_GEOMETRY_MESH_CIRCULATORS_H
#include <pcl/geometry/boost.h>
#include <pcl/geometry/mesh_indices.h>
////////////////////////////////////////////////////////////////////////////////
// VertexAroundVertexCirculator
////////////////////////////////////////////////////////////////////////////////
namespace pcl
{
namespace geometry
{
/** \brief Circulates counter-clockwise around a vertex and returns an index to the terminating vertex of the outgoing half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getVertexAroundVertexCirculator ().
* \tparam MeshT Mesh to which this circulator belongs to.
* \note The circulator can't be used to change the connectivity in the mesh (only const circulators are valid).
* \author Martin Saelzle
* \ingroup geometry
*/
template <class MeshT>
class VertexAroundVertexCirculator
: boost::equality_comparable <pcl::geometry::VertexAroundVertexCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::VertexAroundVertexCirculator <MeshT>
> >
{
public:
typedef boost::equality_comparable <pcl::geometry::VertexAroundVertexCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::VertexAroundVertexCirculator <MeshT> > > Base;
typedef pcl::geometry::VertexAroundVertexCirculator <MeshT> Self;
typedef MeshT Mesh;
typedef typename Mesh::VertexIndex VertexIndex;
typedef typename Mesh::HalfEdgeIndex HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
VertexAroundVertexCirculator ()
: mesh_ (NULL),
idx_outgoing_half_edge_ ()
{
}
/** \brief Construct from the vertex around which we want to circulate. */
VertexAroundVertexCirculator (const VertexIndex& idx_vertex,
Mesh*const mesh)
: mesh_ (mesh),
idx_outgoing_half_edge_ (mesh->getOutgoingHalfEdgeIndex (idx_vertex))
{
}
/** \brief Construct directly from the outgoing half-edge. */
VertexAroundVertexCirculator (const HalfEdgeIndex& idx_outgoing_half_edge,
Mesh*const mesh)
: mesh_ (mesh),
idx_outgoing_half_edge_ (idx_outgoing_half_edge)
{
}
/** \brief Check if the circulator is valid.
* \warning Does NOT check if the stored mesh pointer is valid. You have to ensure this yourself when constructing the circulator. */
inline bool
isValid () const
{
return (idx_outgoing_half_edge_.isValid ());
}
/** \brief Comparison operators (with boost::operators): == !=
* \warning Does NOT check if the circulators belong to the same mesh. Please check this yourself. */
inline bool
operator == (const Self& other) const
{
return (idx_outgoing_half_edge_ == other.idx_outgoing_half_edge_);
}
/** \brief Increment operators (with boost::operators): ++ (pre and post) */
inline Self&
operator ++ ()
{
idx_outgoing_half_edge_ = mesh_->getNextHalfEdgeIndex (mesh_->getOppositeHalfEdgeIndex (idx_outgoing_half_edge_));
return (*this);
}
/** \brief Decrement operators (with boost::operators): -- (pre and post) */
inline Self&
operator -- ()
{
idx_outgoing_half_edge_ = mesh_->getOppositeHalfEdgeIndex (mesh_->getPrevHalfEdgeIndex (idx_outgoing_half_edge_));
return (*this);
}
/** \brief Get the index to the target vertex. */
inline VertexIndex
getTargetIndex () const
{
return (mesh_->getTerminatingVertexIndex (idx_outgoing_half_edge_));
}
/** \brief Get the half-edge that is currently stored in the circulator. */
inline HalfEdgeIndex
getCurrentHalfEdgeIndex () const
{
return (idx_outgoing_half_edge_);
}
/** \brief The mesh to which this circulator belongs to. */
Mesh* mesh_;
/** \brief The outgoing half-edge of the vertex around which we want to circulate. */
HalfEdgeIndex idx_outgoing_half_edge_;
};
} // End namespace geometry
} // End namespace pcl
////////////////////////////////////////////////////////////////////////////////
// OutgoingHalfEdgeAroundVertexCirculator
////////////////////////////////////////////////////////////////////////////////
namespace pcl
{
namespace geometry
{
/** \brief Circulates counter-clockwise around a vertex and returns an index to the outgoing half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getOutgoingHalfEdgeAroundVertexCirculator ().
* \tparam MeshT Mesh to which this circulator belongs to.
* \note The circulator can't be used to change the connectivity in the mesh (only const circulators are valid).
* \author Martin Saelzle
* \ingroup geometry
*/
template <class MeshT>
class OutgoingHalfEdgeAroundVertexCirculator
: boost::equality_comparable <pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator <MeshT>
> >
{
public:
typedef boost::equality_comparable <pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator <MeshT> > > Base;
typedef pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator <MeshT> Self;
typedef MeshT Mesh;
typedef typename Mesh::VertexIndex VertexIndex;
typedef typename Mesh::HalfEdgeIndex HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
OutgoingHalfEdgeAroundVertexCirculator ()
: mesh_ (NULL),
idx_outgoing_half_edge_ ()
{
}
/** \brief Construct from the vertex around which we want to circulate. */
OutgoingHalfEdgeAroundVertexCirculator (const VertexIndex& idx_vertex,
Mesh*const mesh)
: mesh_ (mesh),
idx_outgoing_half_edge_ (mesh->getOutgoingHalfEdgeIndex (idx_vertex))
{
}
/** \brief Construct directly from the outgoing half-edge. */
OutgoingHalfEdgeAroundVertexCirculator (const HalfEdgeIndex& idx_outgoing_half_edge,
Mesh*const mesh)
: mesh_ (mesh),
idx_outgoing_half_edge_ (idx_outgoing_half_edge)
{
}
/** \brief Check if the circulator is valid.
* \warning Does NOT check if the stored mesh pointer is valid. You have to ensure this yourself when constructing the circulator. */
inline bool
isValid () const
{
return (idx_outgoing_half_edge_.isValid ());
}
/** \brief Comparison operators (with boost::operators): == !=
* \warning Does NOT check if the circulators belong to the same mesh. Please check this yourself. */
inline bool
operator == (const Self& other) const
{
return (idx_outgoing_half_edge_ == other.idx_outgoing_half_edge_);
}
/** \brief Increment operators (with boost::operators): ++ (pre and post) */
inline Self&
operator ++ ()
{
idx_outgoing_half_edge_ = mesh_->getNextHalfEdgeIndex (mesh_->getOppositeHalfEdgeIndex (idx_outgoing_half_edge_));
return (*this);
}
/** \brief Decrement operators (with boost::operators): -- (pre and post) */
inline Self&
operator -- ()
{
idx_outgoing_half_edge_ = mesh_->getOppositeHalfEdgeIndex (mesh_->getPrevHalfEdgeIndex (idx_outgoing_half_edge_));
return (*this);
}
/** \brief Get the index to the outgoing half-edge. */
inline HalfEdgeIndex
getTargetIndex () const
{
return (idx_outgoing_half_edge_);
}
/** \brief Get the half-edge that is currently stored in the circulator. */
inline HalfEdgeIndex
getCurrentHalfEdgeIndex () const
{
return (idx_outgoing_half_edge_);
}
/** \brief The mesh to which this circulator belongs to. */
Mesh* mesh_;
/** \brief The outgoing half-edge of the vertex around which we want to circulate. */
HalfEdgeIndex idx_outgoing_half_edge_;
};
} // End namespace geometry
} // End namespace pcl
////////////////////////////////////////////////////////////////////////////////
// IncomingHalfEdgeAroundVertexCirculator
////////////////////////////////////////////////////////////////////////////////
namespace pcl
{
namespace geometry
{
/** \brief Circulates counter-clockwise around a vertex and returns an index to the incoming half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getIncomingHalfEdgeAroundVertexCirculator ().
* \tparam MeshT Mesh to which this circulator belongs to.
* \note The circulator can't be used to change the connectivity in the mesh (only const circulators are valid).
* \author Martin Saelzle
* \ingroup geometry
*/
template <class MeshT>
class IncomingHalfEdgeAroundVertexCirculator
: boost::equality_comparable <pcl::geometry::IncomingHalfEdgeAroundVertexCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::IncomingHalfEdgeAroundVertexCirculator <MeshT>
> >
{
public:
typedef boost::equality_comparable <pcl::geometry::IncomingHalfEdgeAroundVertexCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::IncomingHalfEdgeAroundVertexCirculator <MeshT> > > Base;
typedef pcl::geometry::IncomingHalfEdgeAroundVertexCirculator <MeshT> Self;
typedef MeshT Mesh;
typedef typename Mesh::VertexIndex VertexIndex;
typedef typename Mesh::HalfEdgeIndex HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
IncomingHalfEdgeAroundVertexCirculator ()
: mesh_ (NULL),
idx_incoming_half_edge_ ()
{
}
/** \brief Construct from the vertex around which we want to circulate. */
IncomingHalfEdgeAroundVertexCirculator (const VertexIndex& idx_vertex,
Mesh*const mesh)
: mesh_ (mesh),
idx_incoming_half_edge_ (mesh->getIncomingHalfEdgeIndex (idx_vertex))
{
}
/** \brief Construct directly from the incoming half-edge. */
IncomingHalfEdgeAroundVertexCirculator (const HalfEdgeIndex& idx_incoming_half_edge,
Mesh*const mesh)
: mesh_ (mesh),
idx_incoming_half_edge_ (idx_incoming_half_edge)
{
}
/** \brief Check if the circulator is valid.
* \warning Does NOT check if the stored mesh pointer is valid. You have to ensure this yourself when constructing the circulator. */
inline bool
isValid () const
{
return (idx_incoming_half_edge_.isValid ());
}
/** \brief Comparison operators (with boost::operators): == !=
* \warning Does NOT check if the circulators belong to the same mesh. Please check this yourself. */
inline bool
operator == (const Self& other) const
{
return (idx_incoming_half_edge_ == other.idx_incoming_half_edge_);
}
/** \brief Increment operators (with boost::operators): ++ (pre and post) */
inline Self&
operator ++ ()
{
idx_incoming_half_edge_ = mesh_->getOppositeHalfEdgeIndex (mesh_->getNextHalfEdgeIndex (idx_incoming_half_edge_));
return (*this);
}
/** \brief Decrement operators (with boost::operators): -- (pre and post) */
inline Self&
operator -- ()
{
idx_incoming_half_edge_ = mesh_->getPrevHalfEdgeIndex (mesh_->getOppositeHalfEdgeIndex (idx_incoming_half_edge_));
return (*this);
}
/** \brief Get the index to the incoming half-edge. */
inline HalfEdgeIndex
getTargetIndex () const
{
return (idx_incoming_half_edge_);
}
/** \brief Get the half-edge that is currently stored in the circulator. */
inline HalfEdgeIndex
getCurrentHalfEdgeIndex () const
{
return (idx_incoming_half_edge_);
}
/** \brief The mesh to which this circulator belongs to. */
Mesh* mesh_;
/** \brief The incoming half-edge of the vertex around which we want to circulate. */
HalfEdgeIndex idx_incoming_half_edge_;
};
} // End namespace geometry
} // End namespace pcl
////////////////////////////////////////////////////////////////////////////////
// FaceAroundVertexCirculator
////////////////////////////////////////////////////////////////////////////////
namespace pcl
{
namespace geometry
{
/** \brief Circulates counter-clockwise around a vertex and returns an index to the face of the outgoing half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getFaceAroundVertexCirculator ().
* \tparam MeshT Mesh to which this circulator belongs to.
* \note The circulator can't be used to change the connectivity in the mesh (only const circulators are valid).
* \author Martin Saelzle
* \ingroup geometry
*/
template <class MeshT>
class FaceAroundVertexCirculator
: boost::equality_comparable <pcl::geometry::FaceAroundVertexCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::FaceAroundVertexCirculator <MeshT>
> >
{
public:
typedef boost::equality_comparable <pcl::geometry::FaceAroundVertexCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::FaceAroundVertexCirculator <MeshT> > > Base;
typedef pcl::geometry::FaceAroundVertexCirculator <MeshT> Self;
typedef MeshT Mesh;
typedef typename Mesh::FaceIndex FaceIndex;
typedef typename Mesh::VertexIndex VertexIndex;
typedef typename Mesh::HalfEdgeIndex HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
FaceAroundVertexCirculator ()
: mesh_ (NULL),
idx_outgoing_half_edge_ ()
{
}
/** \brief Construct from the vertex around which we want to circulate. */
FaceAroundVertexCirculator (const VertexIndex& idx_vertex,
Mesh*const mesh)
: mesh_ (mesh),
idx_outgoing_half_edge_ (mesh->getOutgoingHalfEdgeIndex (idx_vertex))
{
}
/** \brief Construct directly from the outgoing half-edge. */
FaceAroundVertexCirculator (const HalfEdgeIndex& idx_outgoing_half_edge,
Mesh*const mesh)
: mesh_ (mesh),
idx_outgoing_half_edge_ (idx_outgoing_half_edge)
{
}
/** \brief Check if the circulator is valid.
* \warning Does NOT check if the stored mesh pointer is valid. You have to ensure this yourself when constructing the circulator. */
inline bool
isValid () const
{
return (idx_outgoing_half_edge_.isValid ());
}
/** \brief Comparison operators (with boost::operators): == !=
* \warning Does NOT check if the circulators belong to the same mesh. Please check this yourself. */
inline bool
operator == (const Self& other) const
{
return (idx_outgoing_half_edge_ == other.idx_outgoing_half_edge_);
}
/** \brief Increment operators (with boost::operators): ++ (pre and post) */
inline Self&
operator ++ ()
{
idx_outgoing_half_edge_ = mesh_->getNextHalfEdgeIndex (mesh_->getOppositeHalfEdgeIndex (idx_outgoing_half_edge_));
return (*this);
}
/** \brief Decrement operators (with boost::operators): -- (pre and post) */
inline Self&
operator -- ()
{
idx_outgoing_half_edge_ = mesh_->getOppositeHalfEdgeIndex (mesh_->getPrevHalfEdgeIndex (idx_outgoing_half_edge_));
return (*this);
}
/** \brief Get the index to the target face. */
inline FaceIndex
getTargetIndex () const
{
return (mesh_->getFaceIndex (idx_outgoing_half_edge_));
}
/** \brief Get the half-edge that is currently stored in the circulator. */
inline HalfEdgeIndex
getCurrentHalfEdgeIndex () const
{
return (idx_outgoing_half_edge_);
}
/** \brief The mesh to which this circulator belongs to. */
Mesh* mesh_;
/** \brief The outgoing half-edge of the vertex around which we want to circulate. */
HalfEdgeIndex idx_outgoing_half_edge_;
};
} // End namespace geometry
} // End namespace pcl
////////////////////////////////////////////////////////////////////////////////
// VertexAroundFaceCirculator
////////////////////////////////////////////////////////////////////////////////
namespace pcl
{
namespace geometry
{
/** \brief Circulates clockwise around a face and returns an index to the terminating vertex of the inner half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getVertexAroundFaceCirculator ().
* \tparam MeshT Mesh to which this circulator belongs to.
* \note The circulator can't be used to change the connectivity in the mesh (only const circulators are valid).
* \author Martin Saelzle
* \ingroup geometry
*/
template <class MeshT>
class VertexAroundFaceCirculator
: boost::equality_comparable <pcl::geometry::VertexAroundFaceCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::VertexAroundFaceCirculator <MeshT>
> >
{
public:
typedef boost::equality_comparable <pcl::geometry::VertexAroundFaceCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::VertexAroundFaceCirculator <MeshT> > > Base;
typedef pcl::geometry::VertexAroundFaceCirculator <MeshT> Self;
typedef MeshT Mesh;
typedef typename Mesh::VertexIndex VertexIndex;
typedef typename Mesh::FaceIndex FaceIndex;
typedef typename Mesh::HalfEdgeIndex HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
VertexAroundFaceCirculator ()
: mesh_ (NULL),
idx_inner_half_edge_ ()
{
}
/** \brief Construct from the face around which we want to circulate. */
VertexAroundFaceCirculator (const FaceIndex& idx_face,
Mesh*const mesh)
: mesh_ (mesh),
idx_inner_half_edge_ (mesh->getInnerHalfEdgeIndex (idx_face))
{
}
/** \brief Construct directly from the inner half-edge. */
VertexAroundFaceCirculator (const HalfEdgeIndex& idx_inner_half_edge,
Mesh*const mesh)
: mesh_ (mesh),
idx_inner_half_edge_ (idx_inner_half_edge)
{
}
/** \brief Check if the circulator is valid.
* \warning Does NOT check if the stored mesh pointer is valid. You have to ensure this yourself when constructing the circulator. */
inline bool
isValid () const
{
return (idx_inner_half_edge_.isValid ());
}
/** \brief Comparison operators (with boost::operators): == !=
* \warning Does NOT check if the circulators belong to the same mesh. Please check this yourself. */
inline bool
operator == (const Self& other) const
{
return (idx_inner_half_edge_ == other.idx_inner_half_edge_);
}
/** \brief Increment operators (with boost::operators): ++ (pre and post) */
inline Self&
operator ++ ()
{
idx_inner_half_edge_ = mesh_->getNextHalfEdgeIndex (idx_inner_half_edge_);
return (*this);
}
/** \brief Decrement operators (with boost::operators): -- (pre and post) */
inline Self&
operator -- ()
{
idx_inner_half_edge_ = mesh_->getPrevHalfEdgeIndex (idx_inner_half_edge_);
return (*this);
}
/** \brief Get the index to the target vertex. */
inline VertexIndex
getTargetIndex () const
{
return (mesh_->getTerminatingVertexIndex (idx_inner_half_edge_));
}
/** \brief Get the half-edge that is currently stored in the circulator. */
inline HalfEdgeIndex
getCurrentHalfEdgeIndex () const
{
return (idx_inner_half_edge_);
}
/** \brief The mesh to which this circulator belongs to. */
Mesh* mesh_;
/** \brief The inner half-edge of the face around which we want to circulate. */
HalfEdgeIndex idx_inner_half_edge_;
};
} // End namespace geometry
} // End namespace pcl
////////////////////////////////////////////////////////////////////////////////
// InnerHalfEdgeAroundFaceCirculator
////////////////////////////////////////////////////////////////////////////////
namespace pcl
{
namespace geometry
{
/** \brief Circulates clockwise around a face and returns an index to the inner half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getInnerHalfEdgeAroundFaceCirculator ().
* \tparam MeshT Mesh to which this circulator belongs to.
* \note The circulator can't be used to change the connectivity in the mesh (only const circulators are valid).
* \author Martin Saelzle
* \ingroup geometry
*/
template <class MeshT>
class InnerHalfEdgeAroundFaceCirculator
: boost::equality_comparable <pcl::geometry::InnerHalfEdgeAroundFaceCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::InnerHalfEdgeAroundFaceCirculator <MeshT>
> >
{
public:
typedef boost::equality_comparable <pcl::geometry::InnerHalfEdgeAroundFaceCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::InnerHalfEdgeAroundFaceCirculator <MeshT> > > Base;
typedef pcl::geometry::InnerHalfEdgeAroundFaceCirculator <MeshT> Self;
typedef MeshT Mesh;
typedef typename Mesh::FaceIndex FaceIndex;
typedef typename Mesh::HalfEdgeIndex HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
InnerHalfEdgeAroundFaceCirculator ()
: mesh_ (NULL),
idx_inner_half_edge_ ()
{
}
/** \brief Construct from the face around which we want to circulate. */
InnerHalfEdgeAroundFaceCirculator (const FaceIndex& idx_face,
Mesh*const mesh)
: mesh_ (mesh),
idx_inner_half_edge_ (mesh->getInnerHalfEdgeIndex (idx_face))
{
}
/** \brief Construct directly from the inner half-edge. */
InnerHalfEdgeAroundFaceCirculator (const HalfEdgeIndex& idx_inner_half_edge,
Mesh*const mesh)
: mesh_ (mesh),
idx_inner_half_edge_ (idx_inner_half_edge)
{
}
/** \brief Check if the circulator is valid.
* \warning Does NOT check if the stored mesh pointer is valid. You have to ensure this yourself when constructing the circulator. */
inline bool
isValid () const
{
return (idx_inner_half_edge_.isValid ());
}
/** \brief Comparison operators (with boost::operators): == !=
* \warning Does NOT check if the circulators belong to the same mesh. Please check this yourself. */
inline bool
operator == (const Self& other) const
{
return (idx_inner_half_edge_ == other.idx_inner_half_edge_);
}
/** \brief Increment operators (with boost::operators): ++ (pre and post) */
inline Self&
operator ++ ()
{
idx_inner_half_edge_ = mesh_->getNextHalfEdgeIndex (idx_inner_half_edge_);
return (*this);
}
/** \brief Decrement operators (with boost::operators): -- (pre and post) */
inline Self&
operator -- ()
{
idx_inner_half_edge_ = mesh_->getPrevHalfEdgeIndex (idx_inner_half_edge_);
return (*this);
}
/** \brief Get the index to the inner half-edge. */
inline HalfEdgeIndex
getTargetIndex () const
{
return (idx_inner_half_edge_);
}
/** \brief Get the half-edge that is currently stored in the circulator. */
inline HalfEdgeIndex
getCurrentHalfEdgeIndex () const
{
return (idx_inner_half_edge_);
}
/** \brief The mesh to which this circulator belongs to. */
Mesh* mesh_;
/** \brief The inner half-edge of the face around which we want to circulate. */
HalfEdgeIndex idx_inner_half_edge_;
};
} // End namespace geometry
} // End namespace pcl
////////////////////////////////////////////////////////////////////////////////
// OuterHalfEdgeAroundFaceCirculator
////////////////////////////////////////////////////////////////////////////////
namespace pcl
{
namespace geometry
{
/** \brief Circulates clockwise around a face and returns an index to the outer half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getOuterHalfEdgeAroundFaceCirculator ().
* \tparam MeshT Mesh to which this circulator belongs to.
* \note The circulator can't be used to change the connectivity in the mesh (only const circulators are valid).
* \author Martin Saelzle
* \ingroup geometry
*/
template <class MeshT>
class OuterHalfEdgeAroundFaceCirculator
: boost::equality_comparable <pcl::geometry::OuterHalfEdgeAroundFaceCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::OuterHalfEdgeAroundFaceCirculator <MeshT>
> >
{
public:
typedef boost::equality_comparable <pcl::geometry::OuterHalfEdgeAroundFaceCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::OuterHalfEdgeAroundFaceCirculator <MeshT> > > Base;
typedef pcl::geometry::OuterHalfEdgeAroundFaceCirculator <MeshT> Self;
typedef MeshT Mesh;
typedef typename Mesh::FaceIndex FaceIndex;
typedef typename Mesh::HalfEdgeIndex HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
OuterHalfEdgeAroundFaceCirculator ()
: mesh_ (NULL),
idx_inner_half_edge_ ()
{
}
/** \brief Construct from the face around which we want to circulate. */
OuterHalfEdgeAroundFaceCirculator (const FaceIndex& idx_face,
Mesh*const mesh)
: mesh_ (mesh),
idx_inner_half_edge_ (mesh->getInnerHalfEdgeIndex (idx_face))
{
}
/** \brief Construct directly from the inner half-edge. */
OuterHalfEdgeAroundFaceCirculator (const HalfEdgeIndex& idx_inner_half_edge,
Mesh*const mesh)
: mesh_ (mesh),
idx_inner_half_edge_ (idx_inner_half_edge)
{
}
/** \brief Check if the circulator is valid.
* \warning Does NOT check if the stored mesh pointer is valid. You have to ensure this yourself when constructing the circulator. */
inline bool
isValid () const
{
return (idx_inner_half_edge_.isValid ());
}
/** \brief Comparison operators (with boost::operators): == !=
* \warning Does NOT check if the circulators belong to the same mesh. Please check this yourself. */
inline bool
operator == (const Self& other) const
{
return (idx_inner_half_edge_ == other.idx_inner_half_edge_);
}
/** \brief Increment operators (with boost::operators): ++ (pre and post) */
inline Self&
operator ++ ()
{
idx_inner_half_edge_ = mesh_->getNextHalfEdgeIndex (idx_inner_half_edge_);
return (*this);
}
/** \brief Decrement operators (with boost::operators): -- (pre and post) */
inline Self&
operator -- ()
{
idx_inner_half_edge_ = mesh_->getPrevHalfEdgeIndex (idx_inner_half_edge_);
return (*this);
}
/** \brief Get the index to the outer half-edge. */
inline HalfEdgeIndex
getTargetIndex () const
{
return (mesh_->getOppositeHalfEdgeIndex (idx_inner_half_edge_));
}
/** \brief Get the half-edge that is currently stored in the circulator. */
inline HalfEdgeIndex
getCurrentHalfEdgeIndex () const
{
return (idx_inner_half_edge_);
}
/** \brief The mesh to which this circulator belongs to. */
Mesh* mesh_;
/** \brief The inner half-edge of the face around which we want to circulate. */
HalfEdgeIndex idx_inner_half_edge_;
};
} // End namespace geometry
} // End namespace pcl
////////////////////////////////////////////////////////////////////////////////
// FaceAroundFaceCirculator
////////////////////////////////////////////////////////////////////////////////
namespace pcl
{
namespace geometry
{
/** \brief Circulates clockwise around a face and returns an index to the face of the outer half-edge (the target). The best way to declare the circulator is to use the method pcl::geometry::MeshBase::getFaceAroundFaceCirculator ().
* \tparam MeshT Mesh to which this circulator belongs to.
* \note The circulator can't be used to change the connectivity in the mesh (only const circulators are valid).
* \author Martin Saelzle
* \ingroup geometry
*/
template <class MeshT>
class FaceAroundFaceCirculator
: boost::equality_comparable <pcl::geometry::FaceAroundFaceCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::FaceAroundFaceCirculator <MeshT>
> >
{
public:
typedef boost::equality_comparable <pcl::geometry::FaceAroundFaceCirculator <MeshT>
, boost::unit_steppable <pcl::geometry::FaceAroundFaceCirculator <MeshT> > > Base;
typedef pcl::geometry::FaceAroundFaceCirculator <MeshT> Self;
typedef MeshT Mesh;
typedef typename Mesh::FaceIndex FaceIndex;
typedef typename Mesh::HalfEdgeIndex HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
FaceAroundFaceCirculator ()
: mesh_ (NULL),
idx_inner_half_edge_ ()
{
}
/** \brief Construct from the face around which we want to circulate. */
FaceAroundFaceCirculator (const FaceIndex& idx_face,
Mesh*const mesh)
: mesh_ (mesh),
idx_inner_half_edge_ (mesh->getInnerHalfEdgeIndex (idx_face))
{
}
/** \brief Construct directly from the inner half-edge. */
FaceAroundFaceCirculator (const HalfEdgeIndex& idx_inner_half_edge,
Mesh*const mesh)
: mesh_ (mesh),
idx_inner_half_edge_ (idx_inner_half_edge)
{
}
/** \brief Check if the circulator is valid.
* \warning Does NOT check if the stored mesh pointer is valid. You have to ensure this yourself when constructing the circulator. */
inline bool
isValid () const
{
return (idx_inner_half_edge_.isValid ());
}
/** \brief Comparison operators (with boost::operators): == !=
* \warning Does NOT check if the circulators belong to the same mesh. Please check this yourself. */
inline bool
operator == (const Self& other) const
{
return (idx_inner_half_edge_ == other.idx_inner_half_edge_);
}
/** \brief Increment operators (with boost::operators): ++ (pre and post) */
inline Self&
operator ++ ()
{
idx_inner_half_edge_ = mesh_->getNextHalfEdgeIndex (idx_inner_half_edge_);
return (*this);
}
/** \brief Decrement operators (with boost::operators): -- (pre and post) */
inline Self&
operator -- ()
{
idx_inner_half_edge_ = mesh_->getPrevHalfEdgeIndex (idx_inner_half_edge_);
return (*this);
}
/** \brief Get the index to the target face. */
inline FaceIndex
getTargetIndex () const
{
return (mesh_->getOppositeFaceIndex (idx_inner_half_edge_));
}
/** \brief Get the half-edge that is currently stored in the circulator. */
inline HalfEdgeIndex
getCurrentHalfEdgeIndex () const
{
return (idx_inner_half_edge_);
}
/** \brief The mesh to which this circulator belongs to. */
Mesh* mesh_;
/** \brief The inner half-edge of the face around which we want to circulate. */
HalfEdgeIndex idx_inner_half_edge_;
};
} // End namespace geometry
} // End namespace pcl
#endif // PCL_GEOMETRY_MESH_CIRCULATORS_H
pcl::geometry::VertexAroundVertexCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition: mesh_circulators.h:143
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::Base
boost::equality_comparable< pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< MeshT >, boost::unit_steppable< pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< MeshT > > > Base
Definition: mesh_circulators.h:180
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition: mesh_circulators.h:359
pcl::geometry::FaceAroundFaceCirculator::idx_inner_half_edge_
HalfEdgeIndex idx_inner_half_edge_
The inner half-edge of the face around which we want to circulate.
Definition: mesh_circulators.h:910
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::FaceIndex
Mesh::FaceIndex FaceIndex
Definition: mesh_circulators.h:726
pcl::geometry::VertexAroundVertexCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition: mesh_circulators.h:105
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::Mesh
MeshT Mesh
Definition: mesh_circulators.h:291
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition: mesh_circulators.h:213
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::HalfEdgeIndex
Mesh::HalfEdgeIndex HalfEdgeIndex
Definition: mesh_circulators.h:293
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition: mesh_circulators.h:793
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::HalfEdgeIndex
Mesh::HalfEdgeIndex HalfEdgeIndex
Definition: mesh_circulators.h:727
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition: mesh_circulators.h:755
pcl::geometry::FaceAroundFaceCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition: mesh_circulators.h:901
pcl::geometry::FaceAroundVertexCirculator::FaceAroundVertexCirculator
FaceAroundVertexCirculator(const VertexIndex &idx_vertex, Mesh *const mesh)
Construct from the vertex around which we want to circulate.
Definition: mesh_circulators.h:412
pcl::geometry::VertexAroundVertexCirculator::operator--
Self & operator--()
Decrement operators (with boost::operators): – (pre and post)
Definition: mesh_circulators.h:128
pcl::geometry::VertexAroundVertexCirculator::VertexIndex
Mesh::VertexIndex VertexIndex
Definition: mesh_circulators.h:76
pcl::geometry::FaceAroundFaceCirculator::Base
boost::equality_comparable< pcl::geometry::FaceAroundFaceCirculator< MeshT >, boost::unit_steppable< pcl::geometry::FaceAroundFaceCirculator< MeshT > > > Base
Definition: mesh_circulators.h:830
pcl
Definition: convolution.h:45
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition: mesh_circulators.h:251
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::HalfEdgeIndex
Mesh::HalfEdgeIndex HalfEdgeIndex
Definition: mesh_circulators.h:185
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::idx_incoming_half_edge_
HalfEdgeIndex idx_incoming_half_edge_
The incoming half-edge of the vertex around which we want to circulate.
Definition: mesh_circulators.h:368
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::idx_inner_half_edge_
HalfEdgeIndex idx_inner_half_edge_
The inner half-edge of the face around which we want to circulate.
Definition: mesh_circulators.h:694
pcl::geometry::FaceAroundFaceCirculator
Circulates clockwise around a face and returns an index to the face of the outer half-edge (the targe...
Definition: mesh_circulators.h:822
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator
Circulates counter-clockwise around a vertex and returns an index to the incoming half-edge (the targ...
Definition: mesh_circulators.h:280
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::OutgoingHalfEdgeAroundVertexCirculator
OutgoingHalfEdgeAroundVertexCirculator(const VertexIndex &idx_vertex, Mesh *const mesh)
Construct from the vertex around which we want to circulate.
Definition: mesh_circulators.h:195
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::HalfEdgeIndex
Mesh::HalfEdgeIndex HalfEdgeIndex
Definition: mesh_circulators.h:619
pcl::geometry::VertexAroundFaceCirculator::FaceIndex
Mesh::FaceIndex FaceIndex
Definition: mesh_circulators.h:510
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::Mesh
MeshT Mesh
Definition: mesh_circulators.h:183
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::mesh_
Mesh * mesh_
The mesh to which this circulator belongs to.
Definition: mesh_circulators.h:799
pcl::geometry::VertexAroundFaceCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition: mesh_circulators.h:539
pcl::geometry::VertexAroundVertexCirculator::mesh_
Mesh * mesh_
The mesh to which this circulator belongs to.
Definition: mesh_circulators.h:149
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition: mesh_circulators.h:321
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::Mesh
MeshT Mesh
Definition: mesh_circulators.h:617
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::IncomingHalfEdgeAroundVertexCirculator
IncomingHalfEdgeAroundVertexCirculator(const HalfEdgeIndex &idx_incoming_half_edge, Mesh *const mesh)
Construct directly from the incoming half-edge.
Definition: mesh_circulators.h:311
pcl::geometry::VertexAroundFaceCirculator::Self
pcl::geometry::VertexAroundFaceCirculator< MeshT > Self
Definition: mesh_circulators.h:506
pcl::geometry::FaceAroundVertexCirculator::FaceIndex
Mesh::FaceIndex FaceIndex
Definition: mesh_circulators.h:400
pcl::geometry::VertexAroundVertexCirculator::HalfEdgeIndex
Mesh::HalfEdgeIndex HalfEdgeIndex
Definition: mesh_circulators.h:77
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::getTargetIndex
HalfEdgeIndex getTargetIndex() const
Get the index to the outer half-edge.
Definition: mesh_circulators.h:786
pcl::geometry::VertexAroundFaceCirculator::VertexAroundFaceCirculator
VertexAroundFaceCirculator(const HalfEdgeIndex &idx_inner_half_edge, Mesh *const mesh)
Construct directly from the inner half-edge.
Definition: mesh_circulators.h:529
pcl::geometry::FaceAroundVertexCirculator::mesh_
Mesh * mesh_
The mesh to which this circulator belongs to.
Definition: mesh_circulators.h:474
pcl::geometry::VertexAroundVertexCirculator::getTargetIndex
VertexIndex getTargetIndex() const
Get the index to the target vertex.
Definition: mesh_circulators.h:136
pcl::geometry::FaceAroundFaceCirculator::Mesh
MeshT Mesh
Definition: mesh_circulators.h:833
pcl::geometry::VertexAroundVertexCirculator::VertexAroundVertexCirculator
VertexAroundVertexCirculator(const VertexIndex &idx_vertex, Mesh *const mesh)
Construct from the vertex around which we want to circulate.
Definition: mesh_circulators.h:87
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::OutgoingHalfEdgeAroundVertexCirculator
OutgoingHalfEdgeAroundVertexCirculator(const HalfEdgeIndex &idx_outgoing_half_edge, Mesh *const mesh)
Construct directly from the outgoing half-edge.
Definition: mesh_circulators.h:203
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::OuterHalfEdgeAroundFaceCirculator
OuterHalfEdgeAroundFaceCirculator(const FaceIndex &idx_face, Mesh *const mesh)
Construct from the face around which we want to circulate.
Definition: mesh_circulators.h:737
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::getTargetIndex
HalfEdgeIndex getTargetIndex() const
Get the index to the incoming half-edge.
Definition: mesh_circulators.h:352
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::mesh_
Mesh * mesh_
The mesh to which this circulator belongs to.
Definition: mesh_circulators.h:365
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::InnerHalfEdgeAroundFaceCirculator
InnerHalfEdgeAroundFaceCirculator(const HalfEdgeIndex &idx_inner_half_edge, Mesh *const mesh)
Construct directly from the inner half-edge.
Definition: mesh_circulators.h:637
pcl::geometry::VertexAroundFaceCirculator::idx_inner_half_edge_
HalfEdgeIndex idx_inner_half_edge_
The inner half-edge of the face around which we want to circulate.
Definition: mesh_circulators.h:586
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::VertexIndex
Mesh::VertexIndex VertexIndex
Definition: mesh_circulators.h:184
pcl::geometry::FaceAroundFaceCirculator::FaceAroundFaceCirculator
FaceAroundFaceCirculator()
Constructor resulting in an invalid circulator.
Definition: mesh_circulators.h:838
pcl::geometry::VertexAroundVertexCirculator
Circulates counter-clockwise around a vertex and returns an index to the terminating vertex of the ou...
Definition: mesh_circulators.h:64
pcl::geometry::FaceAroundFaceCirculator::HalfEdgeIndex
Mesh::HalfEdgeIndex HalfEdgeIndex
Definition: mesh_circulators.h:835
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::FaceIndex
Mesh::FaceIndex FaceIndex
Definition: mesh_circulators.h:618
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition: mesh_circulators.h:647
pcl::geometry::FaceAroundFaceCirculator::mesh_
Mesh * mesh_
The mesh to which this circulator belongs to.
Definition: mesh_circulators.h:907
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::Base
boost::equality_comparable< pcl::geometry::OuterHalfEdgeAroundFaceCirculator< MeshT >, boost::unit_steppable< pcl::geometry::OuterHalfEdgeAroundFaceCirculator< MeshT > > > Base
Definition: mesh_circulators.h:722
pcl::geometry::VertexAroundFaceCirculator::VertexIndex
Mesh::VertexIndex VertexIndex
Definition: mesh_circulators.h:509
pcl::geometry::VertexAroundFaceCirculator
Circulates clockwise around a face and returns an index to the terminating vertex of the inner half-e...
Definition: mesh_circulators.h:497
pcl::geometry::FaceAroundVertexCirculator::Self
pcl::geometry::FaceAroundVertexCirculator< MeshT > Self
Definition: mesh_circulators.h:397
pcl::geometry::VertexAroundFaceCirculator::Base
boost::equality_comparable< pcl::geometry::VertexAroundFaceCirculator< MeshT >, boost::unit_steppable< pcl::geometry::VertexAroundFaceCirculator< MeshT > > > Base
Definition: mesh_circulators.h:505
pcl::geometry::VertexAroundVertexCirculator::idx_outgoing_half_edge_
HalfEdgeIndex idx_outgoing_half_edge_
The outgoing half-edge of the vertex around which we want to circulate.
Definition: mesh_circulators.h:152
pcl::geometry::VertexAroundFaceCirculator::mesh_
Mesh * mesh_
The mesh to which this circulator belongs to.
Definition: mesh_circulators.h:583
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::idx_inner_half_edge_
HalfEdgeIndex idx_inner_half_edge_
The inner half-edge of the face around which we want to circulate.
Definition: mesh_circulators.h:802
pcl::geometry::FaceAroundFaceCirculator::Self
pcl::geometry::FaceAroundFaceCirculator< MeshT > Self
Definition: mesh_circulators.h:831
pcl::geometry::VertexAroundVertexCirculator::operator++
Self & operator++()
Increment operators (with boost::operators): ++ (pre and post)
Definition: mesh_circulators.h:120
pcl::geometry::FaceAroundVertexCirculator::Base
boost::equality_comparable< pcl::geometry::FaceAroundVertexCirculator< MeshT >, boost::unit_steppable< pcl::geometry::FaceAroundVertexCirculator< MeshT > > > Base
Definition: mesh_circulators.h:396
pcl::geometry::FaceAroundVertexCirculator::HalfEdgeIndex
Mesh::HalfEdgeIndex HalfEdgeIndex
Definition: mesh_circulators.h:402
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator
Circulates counter-clockwise around a vertex and returns an index to the outgoing half-edge (the targ...
Definition: mesh_circulators.h:172
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::getTargetIndex
HalfEdgeIndex getTargetIndex() const
Get the index to the outgoing half-edge.
Definition: mesh_circulators.h:244
pcl::geometry::VertexAroundVertexCirculator::Self
pcl::geometry::VertexAroundVertexCirculator< MeshT > Self
Definition: mesh_circulators.h:73
pcl::geometry::FaceAroundVertexCirculator::Mesh
MeshT Mesh
Definition: mesh_circulators.h:399
pcl::geometry::FaceAroundVertexCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition: mesh_circulators.h:430
pcl::geometry::VertexAroundVertexCirculator::Base
boost::equality_comparable< pcl::geometry::VertexAroundVertexCirculator< MeshT >, boost::unit_steppable< pcl::geometry::VertexAroundVertexCirculator< MeshT > > > Base
Definition: mesh_circulators.h:72
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::Self
pcl::geometry::InnerHalfEdgeAroundFaceCirculator< MeshT > Self
Definition: mesh_circulators.h:615
pcl::geometry::VertexAroundFaceCirculator::VertexAroundFaceCirculator
VertexAroundFaceCirculator(const FaceIndex &idx_face, Mesh *const mesh)
Construct from the face around which we want to circulate.
Definition: mesh_circulators.h:521
pcl::geometry::FaceAroundFaceCirculator::FaceIndex
Mesh::FaceIndex FaceIndex
Definition: mesh_circulators.h:834
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::Base
boost::equality_comparable< pcl::geometry::InnerHalfEdgeAroundFaceCirculator< MeshT >, boost::unit_steppable< pcl::geometry::InnerHalfEdgeAroundFaceCirculator< MeshT > > > Base
Definition: mesh_circulators.h:614
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::OuterHalfEdgeAroundFaceCirculator
OuterHalfEdgeAroundFaceCirculator()
Constructor resulting in an invalid circulator.
Definition: mesh_circulators.h:730
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::InnerHalfEdgeAroundFaceCirculator
InnerHalfEdgeAroundFaceCirculator(const FaceIndex &idx_face, Mesh *const mesh)
Construct from the face around which we want to circulate.
Definition: mesh_circulators.h:629
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::VertexIndex
Mesh::VertexIndex VertexIndex
Definition: mesh_circulators.h:292
pcl::geometry::VertexAroundVertexCirculator::Mesh
MeshT Mesh
Definition: mesh_circulators.h:75
pcl::geometry::VertexAroundVertexCirculator::VertexAroundVertexCirculator
VertexAroundVertexCirculator()
Constructor resulting in an invalid circulator.
Definition: mesh_circulators.h:80
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::getTargetIndex
HalfEdgeIndex getTargetIndex() const
Get the index to the inner half-edge.
Definition: mesh_circulators.h:678
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::Self
pcl::geometry::OuterHalfEdgeAroundFaceCirculator< MeshT > Self
Definition: mesh_circulators.h:723
pcl::geometry::VertexAroundFaceCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition: mesh_circulators.h:577
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::InnerHalfEdgeAroundFaceCirculator
InnerHalfEdgeAroundFaceCirculator()
Constructor resulting in an invalid circulator.
Definition: mesh_circulators.h:622
pcl::geometry::FaceAroundFaceCirculator::FaceAroundFaceCirculator
FaceAroundFaceCirculator(const HalfEdgeIndex &idx_inner_half_edge, Mesh *const mesh)
Construct directly from the inner half-edge.
Definition: mesh_circulators.h:853
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::mesh_
Mesh * mesh_
The mesh to which this circulator belongs to.
Definition: mesh_circulators.h:257
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::Mesh
MeshT Mesh
Definition: mesh_circulators.h:725
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition: mesh_circulators.h:685
pcl::geometry::VertexAroundFaceCirculator::HalfEdgeIndex
Mesh::HalfEdgeIndex HalfEdgeIndex
Definition: mesh_circulators.h:511
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::Self
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< MeshT > Self
Definition: mesh_circulators.h:181
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::mesh_
Mesh * mesh_
The mesh to which this circulator belongs to.
Definition: mesh_circulators.h:691
pcl::geometry::FaceAroundVertexCirculator::getTargetIndex
FaceIndex getTargetIndex() const
Get the index to the target face.
Definition: mesh_circulators.h:461
pcl::geometry::FaceAroundFaceCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition: mesh_circulators.h:863
pcl::geometry::VertexAroundVertexCirculator::operator==
bool operator==(const Self &other) const
Comparison operators (with boost::operators): == !=.
Definition: mesh_circulators.h:113
pcl::geometry::InnerHalfEdgeAroundFaceCirculator
Circulates clockwise around a face and returns an index to the inner half-edge (the target)...
Definition: mesh_circulators.h:606
pcl::geometry::VertexAroundFaceCirculator::VertexAroundFaceCirculator
VertexAroundFaceCirculator()
Constructor resulting in an invalid circulator.
Definition: mesh_circulators.h:514
pcl::geometry::FaceAroundVertexCirculator::VertexIndex
Mesh::VertexIndex VertexIndex
Definition: mesh_circulators.h:401
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::idx_outgoing_half_edge_
HalfEdgeIndex idx_outgoing_half_edge_
The outgoing half-edge of the vertex around which we want to circulate.
Definition: mesh_circulators.h:260
pcl::geometry::FaceAroundVertexCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition: mesh_circulators.h:468
pcl::geometry::OuterHalfEdgeAroundFaceCirculator
Circulates clockwise around a face and returns an index to the outer half-edge (the target)...
Definition: mesh_circulators.h:714
pcl::geometry::FaceAroundVertexCirculator
Circulates counter-clockwise around a vertex and returns an index to the face of the outgoing half-ed...
Definition: mesh_circulators.h:388
pcl::geometry::FaceAroundFaceCirculator::FaceAroundFaceCirculator
FaceAroundFaceCirculator(const FaceIndex &idx_face, Mesh *const mesh)
Construct from the face around which we want to circulate.
Definition: mesh_circulators.h:845
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::Base
boost::equality_comparable< pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< MeshT >, boost::unit_steppable< pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< MeshT > > > Base
Definition: mesh_circulators.h:288
pcl::geometry::FaceAroundVertexCirculator::FaceAroundVertexCirculator
FaceAroundVertexCirculator(const HalfEdgeIndex &idx_outgoing_half_edge, Mesh *const mesh)
Construct directly from the outgoing half-edge.
Definition: mesh_circulators.h:420
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::IncomingHalfEdgeAroundVertexCirculator
IncomingHalfEdgeAroundVertexCirculator(const VertexIndex &idx_vertex, Mesh *const mesh)
Construct from the vertex around which we want to circulate.
Definition: mesh_circulators.h:303
pcl::geometry::FaceAroundFaceCirculator::getTargetIndex
FaceIndex getTargetIndex() const
Get the index to the target face.
Definition: mesh_circulators.h:894
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::IncomingHalfEdgeAroundVertexCirculator
IncomingHalfEdgeAroundVertexCirculator()
Constructor resulting in an invalid circulator.
Definition: mesh_circulators.h:296
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::OuterHalfEdgeAroundFaceCirculator
OuterHalfEdgeAroundFaceCirculator(const HalfEdgeIndex &idx_inner_half_edge, Mesh *const mesh)
Construct directly from the inner half-edge.
Definition: mesh_circulators.h:745
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::Self
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< MeshT > Self
Definition: mesh_circulators.h:289
pcl::geometry::FaceAroundVertexCirculator::idx_outgoing_half_edge_
HalfEdgeIndex idx_outgoing_half_edge_
The outgoing half-edge of the vertex around which we want to circulate.
Definition: mesh_circulators.h:477
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::OutgoingHalfEdgeAroundVertexCirculator
OutgoingHalfEdgeAroundVertexCirculator()
Constructor resulting in an invalid circulator.
Definition: mesh_circulators.h:188
pcl::geometry::FaceAroundVertexCirculator::FaceAroundVertexCirculator
FaceAroundVertexCirculator()
Constructor resulting in an invalid circulator.
Definition: mesh_circulators.h:405
pcl::geometry::VertexAroundFaceCirculator::Mesh
MeshT Mesh
Definition: mesh_circulators.h:508
pcl::geometry::VertexAroundVertexCirculator::VertexAroundVertexCirculator
VertexAroundVertexCirculator(const HalfEdgeIndex &idx_outgoing_half_edge, Mesh *const mesh)
Construct directly from the outgoing half-edge.
Definition: mesh_circulators.h:95
pcl::geometry::VertexAroundFaceCirculator::getTargetIndex
VertexIndex getTargetIndex() const
Get the index to the target vertex.
Definition: mesh_circulators.h:570