Loading...
Searching...
No Matches
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'
#pragma once
#include <pcl/geometry/mesh_indices.h>
#include <boost/operators.hpp>
////////////////////////////////////////////////////////////////////////////////
// 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:
using Base = boost::equality_comparable<
pcl::geometry::VertexAroundVertexCirculator<MeshT>,
boost::unit_steppable<pcl::geometry::VertexAroundVertexCirculator<MeshT>>>;
using Self = pcl::geometry::VertexAroundVertexCirculator<MeshT>;
using Mesh = MeshT;
using VertexIndex = typename Mesh::VertexIndex;
using HalfEdgeIndex = typename Mesh::HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
VertexAroundVertexCirculator() : mesh_(nullptr), 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:
using Base = boost::equality_comparable<
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator<MeshT>,
boost::unit_steppable<
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator<MeshT>>>;
using Self = pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator<MeshT>;
using Mesh = MeshT;
using VertexIndex = typename Mesh::VertexIndex;
using HalfEdgeIndex = typename Mesh::HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
OutgoingHalfEdgeAroundVertexCirculator() : mesh_(nullptr), 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:
using Base = boost::equality_comparable<
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator<MeshT>,
boost::unit_steppable<
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator<MeshT>>>;
using Self = pcl::geometry::IncomingHalfEdgeAroundVertexCirculator<MeshT>;
using Mesh = MeshT;
using VertexIndex = typename Mesh::VertexIndex;
using HalfEdgeIndex = typename Mesh::HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
IncomingHalfEdgeAroundVertexCirculator() : mesh_(nullptr), 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:
using Base = boost::equality_comparable<
pcl::geometry::FaceAroundVertexCirculator<MeshT>,
boost::unit_steppable<pcl::geometry::FaceAroundVertexCirculator<MeshT>>>;
using Self = pcl::geometry::FaceAroundVertexCirculator<MeshT>;
using Mesh = MeshT;
using FaceIndex = typename Mesh::FaceIndex;
using VertexIndex = typename Mesh::VertexIndex;
using HalfEdgeIndex = typename Mesh::HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
FaceAroundVertexCirculator() : mesh_(nullptr), 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:
using Base = boost::equality_comparable<
pcl::geometry::VertexAroundFaceCirculator<MeshT>,
boost::unit_steppable<pcl::geometry::VertexAroundFaceCirculator<MeshT>>>;
using Self = pcl::geometry::VertexAroundFaceCirculator<MeshT>;
using Mesh = MeshT;
using VertexIndex = typename Mesh::VertexIndex;
using FaceIndex = typename Mesh::FaceIndex;
using HalfEdgeIndex = typename Mesh::HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
VertexAroundFaceCirculator() : mesh_(nullptr), 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:
using Base = boost::equality_comparable<
pcl::geometry::InnerHalfEdgeAroundFaceCirculator<MeshT>,
boost::unit_steppable<pcl::geometry::InnerHalfEdgeAroundFaceCirculator<MeshT>>>;
using Self = pcl::geometry::InnerHalfEdgeAroundFaceCirculator<MeshT>;
using Mesh = MeshT;
using FaceIndex = typename Mesh::FaceIndex;
using HalfEdgeIndex = typename Mesh::HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
InnerHalfEdgeAroundFaceCirculator() : mesh_(nullptr), 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:
using Base = boost::equality_comparable<
pcl::geometry::OuterHalfEdgeAroundFaceCirculator<MeshT>,
boost::unit_steppable<pcl::geometry::OuterHalfEdgeAroundFaceCirculator<MeshT>>>;
using Self = pcl::geometry::OuterHalfEdgeAroundFaceCirculator<MeshT>;
using Mesh = MeshT;
using FaceIndex = typename Mesh::FaceIndex;
using HalfEdgeIndex = typename Mesh::HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
OuterHalfEdgeAroundFaceCirculator() : mesh_(nullptr), 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:
using Base = boost::equality_comparable<
pcl::geometry::FaceAroundFaceCirculator<MeshT>,
boost::unit_steppable<pcl::geometry::FaceAroundFaceCirculator<MeshT>>>;
using Self = pcl::geometry::FaceAroundFaceCirculator<MeshT>;
using Mesh = MeshT;
using FaceIndex = typename Mesh::FaceIndex;
using HalfEdgeIndex = typename Mesh::HalfEdgeIndex;
/** \brief Constructor resulting in an invalid circulator. */
FaceAroundFaceCirculator() : mesh_(nullptr), 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
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:794
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:814
pcl::geometry::FaceAroundFaceCirculator< const Self >::Self
pcl::geometry::FaceAroundFaceCirculator< const Self > Self
Definition mesh_circulators.h:799
pcl::geometry::FaceAroundFaceCirculator::operator++
Self & operator++()
Increment operators (with boost::operators): ++ (pre and post).
Definition mesh_circulators.h:838
pcl::geometry::FaceAroundFaceCirculator< const Self >::Base
boost::equality_comparable< pcl::geometry::FaceAroundFaceCirculator< const Self >, boost::unit_steppable< pcl::geometry::FaceAroundFaceCirculator< const Self > > > Base
Definition mesh_circulators.h:796
pcl::geometry::FaceAroundFaceCirculator::operator==
bool operator==(const Self &other) const
Comparison operators (with boost::operators): == !=.
Definition mesh_circulators.h:831
pcl::geometry::FaceAroundFaceCirculator< const Self >::idx_inner_half_edge_
HalfEdgeIndex idx_inner_half_edge_
Definition mesh_circulators.h:870
pcl::geometry::FaceAroundFaceCirculator< const Self >::mesh_
Mesh * mesh_
Definition mesh_circulators.h:867
pcl::geometry::FaceAroundFaceCirculator< const Self >::FaceIndex
typename Mesh::FaceIndex FaceIndex
Definition mesh_circulators.h:802
pcl::geometry::FaceAroundFaceCirculator< const Self >::HalfEdgeIndex
typename Mesh::HalfEdgeIndex HalfEdgeIndex
Definition mesh_circulators.h:803
pcl::geometry::FaceAroundFaceCirculator::operator--
Self & operator--()
Decrement operators (with boost::operators): – (pre and post).
Definition mesh_circulators.h:846
pcl::geometry::FaceAroundFaceCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition mesh_circulators.h:822
pcl::geometry::FaceAroundFaceCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition mesh_circulators.h:861
pcl::geometry::FaceAroundFaceCirculator::getTargetIndex
FaceIndex getTargetIndex() const
Get the index to the target face.
Definition mesh_circulators.h:854
pcl::geometry::FaceAroundFaceCirculator< const Self >::Mesh
const Self Mesh
Definition mesh_circulators.h:801
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:809
pcl::geometry::FaceAroundFaceCirculator::FaceAroundFaceCirculator
FaceAroundFaceCirculator()
Constructor resulting in an invalid circulator.
Definition mesh_circulators.h:806
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:387
pcl::geometry::FaceAroundVertexCirculator< const Self >::idx_outgoing_half_edge_
HalfEdgeIndex idx_outgoing_half_edge_
Definition mesh_circulators.h:467
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:408
pcl::geometry::FaceAroundVertexCirculator::getTargetIndex
FaceIndex getTargetIndex() const
Get the index to the target face.
Definition mesh_circulators.h:451
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:403
pcl::geometry::FaceAroundVertexCirculator< const Self >::VertexIndex
typename Mesh::VertexIndex VertexIndex
Definition mesh_circulators.h:396
pcl::geometry::FaceAroundVertexCirculator< const Self >::FaceIndex
typename Mesh::FaceIndex FaceIndex
Definition mesh_circulators.h:395
pcl::geometry::FaceAroundVertexCirculator< const Self >::Base
boost::equality_comparable< pcl::geometry::FaceAroundVertexCirculator< const Self >, boost::unit_steppable< pcl::geometry::FaceAroundVertexCirculator< const Self > > > Base
Definition mesh_circulators.h:389
pcl::geometry::FaceAroundVertexCirculator< const Self >::Self
pcl::geometry::FaceAroundVertexCirculator< const Self > Self
Definition mesh_circulators.h:392
pcl::geometry::FaceAroundVertexCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition mesh_circulators.h:417
pcl::geometry::FaceAroundVertexCirculator< const Self >::HalfEdgeIndex
typename Mesh::HalfEdgeIndex HalfEdgeIndex
Definition mesh_circulators.h:397
pcl::geometry::FaceAroundVertexCirculator::FaceAroundVertexCirculator
FaceAroundVertexCirculator()
Constructor resulting in an invalid circulator.
Definition mesh_circulators.h:400
pcl::geometry::FaceAroundVertexCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition mesh_circulators.h:458
pcl::geometry::FaceAroundVertexCirculator::operator==
bool operator==(const Self &other) const
Comparison operators (with boost::operators): == !=.
Definition mesh_circulators.h:426
pcl::geometry::FaceAroundVertexCirculator::operator++
Self & operator++()
Increment operators (with boost::operators): ++ (pre and post).
Definition mesh_circulators.h:433
pcl::geometry::FaceAroundVertexCirculator< const Self >::mesh_
Mesh * mesh_
Definition mesh_circulators.h:464
pcl::geometry::FaceAroundVertexCirculator::operator--
Self & operator--()
Decrement operators (with boost::operators): – (pre and post).
Definition mesh_circulators.h:442
pcl::geometry::FaceAroundVertexCirculator< const Self >::Mesh
const Self Mesh
Definition mesh_circulators.h:394
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator
Circulates counter-clockwise around a vertex and returns an index to the incoming half-edge (the targ...
Definition mesh_circulators.h:281
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< const Self >::HalfEdgeIndex
typename Mesh::HalfEdgeIndex HalfEdgeIndex
Definition mesh_circulators.h:291
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:304
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< const Self >::idx_incoming_half_edge_
HalfEdgeIndex idx_incoming_half_edge_
Definition mesh_circulators.h:363
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::getTargetIndex
HalfEdgeIndex getTargetIndex() const
Get the index to the incoming half-edge.
Definition mesh_circulators.h:347
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::operator==
bool operator==(const Self &other) const
Comparison operators (with boost::operators): == !=.
Definition mesh_circulators.h:322
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::operator--
Self & operator--()
Decrement operators (with boost::operators): – (pre and post).
Definition mesh_circulators.h:338
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< const Self >::Self
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< const Self > Self
Definition mesh_circulators.h:287
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< const Self >::Mesh
const Self Mesh
Definition mesh_circulators.h:289
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::IncomingHalfEdgeAroundVertexCirculator
IncomingHalfEdgeAroundVertexCirculator()
Constructor resulting in an invalid circulator.
Definition mesh_circulators.h:294
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::operator++
Self & operator++()
Increment operators (with boost::operators): ++ (pre and post).
Definition mesh_circulators.h:329
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< const Self >::VertexIndex
typename Mesh::VertexIndex VertexIndex
Definition mesh_circulators.h:290
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< const Self >::Base
boost::equality_comparable< pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< const Self >, boost::unit_steppable< pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< const Self > > > Base
Definition mesh_circulators.h:283
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition mesh_circulators.h:354
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:298
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator< const Self >::mesh_
Mesh * mesh_
Definition mesh_circulators.h:360
pcl::geometry::IncomingHalfEdgeAroundVertexCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition mesh_circulators.h:313
pcl::geometry::InnerHalfEdgeAroundFaceCirculator
Circulates clockwise around a face and returns an index to the inner half-edge (the target).
Definition mesh_circulators.h:592
pcl::geometry::InnerHalfEdgeAroundFaceCirculator< const Self >::HalfEdgeIndex
typename Mesh::HalfEdgeIndex HalfEdgeIndex
Definition mesh_circulators.h:601
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::InnerHalfEdgeAroundFaceCirculator
InnerHalfEdgeAroundFaceCirculator()
Constructor resulting in an invalid circulator.
Definition mesh_circulators.h:604
pcl::geometry::InnerHalfEdgeAroundFaceCirculator< const Self >::Mesh
const Self Mesh
Definition mesh_circulators.h:599
pcl::geometry::InnerHalfEdgeAroundFaceCirculator< const Self >::idx_inner_half_edge_
HalfEdgeIndex idx_inner_half_edge_
Definition mesh_circulators.h:669
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::operator==
bool operator==(const Self &other) const
Comparison operators (with boost::operators): == !=.
Definition mesh_circulators.h:630
pcl::geometry::InnerHalfEdgeAroundFaceCirculator< const Self >::mesh_
Mesh * mesh_
Definition mesh_circulators.h:666
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::getTargetIndex
HalfEdgeIndex getTargetIndex() const
Get the index to the inner half-edge.
Definition mesh_circulators.h:653
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition mesh_circulators.h:621
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition mesh_circulators.h:660
pcl::geometry::InnerHalfEdgeAroundFaceCirculator< const Self >::FaceIndex
typename Mesh::FaceIndex FaceIndex
Definition mesh_circulators.h:600
pcl::geometry::InnerHalfEdgeAroundFaceCirculator< const Self >::Base
boost::equality_comparable< pcl::geometry::InnerHalfEdgeAroundFaceCirculator< const Self >, boost::unit_steppable< pcl::geometry::InnerHalfEdgeAroundFaceCirculator< const Self > > > Base
Definition mesh_circulators.h:594
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:612
pcl::geometry::InnerHalfEdgeAroundFaceCirculator< const Self >::Self
pcl::geometry::InnerHalfEdgeAroundFaceCirculator< const Self > Self
Definition mesh_circulators.h:597
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::operator--
Self & operator--()
Decrement operators (with boost::operators): – (pre and post).
Definition mesh_circulators.h:645
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:607
pcl::geometry::InnerHalfEdgeAroundFaceCirculator::operator++
Self & operator++()
Increment operators (with boost::operators): ++ (pre and post).
Definition mesh_circulators.h:637
pcl::geometry::OuterHalfEdgeAroundFaceCirculator
Circulates clockwise around a face and returns an index to the outer half-edge (the target).
Definition mesh_circulators.h:693
pcl::geometry::OuterHalfEdgeAroundFaceCirculator< const Self >::Self
pcl::geometry::OuterHalfEdgeAroundFaceCirculator< const Self > Self
Definition mesh_circulators.h:698
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::operator++
Self & operator++()
Increment operators (with boost::operators): ++ (pre and post).
Definition mesh_circulators.h:738
pcl::geometry::OuterHalfEdgeAroundFaceCirculator< const Self >::FaceIndex
typename Mesh::FaceIndex FaceIndex
Definition mesh_circulators.h:701
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::getTargetIndex
HalfEdgeIndex getTargetIndex() const
Get the index to the outer half-edge.
Definition mesh_circulators.h:754
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:713
pcl::geometry::OuterHalfEdgeAroundFaceCirculator< const Self >::HalfEdgeIndex
typename Mesh::HalfEdgeIndex HalfEdgeIndex
Definition mesh_circulators.h:702
pcl::geometry::OuterHalfEdgeAroundFaceCirculator< const Self >::Base
boost::equality_comparable< pcl::geometry::OuterHalfEdgeAroundFaceCirculator< const Self >, boost::unit_steppable< pcl::geometry::OuterHalfEdgeAroundFaceCirculator< const Self > > > Base
Definition mesh_circulators.h:695
pcl::geometry::OuterHalfEdgeAroundFaceCirculator< const Self >::mesh_
Mesh * mesh_
Definition mesh_circulators.h:767
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::operator--
Self & operator--()
Decrement operators (with boost::operators): – (pre and post).
Definition mesh_circulators.h:746
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:708
pcl::geometry::OuterHalfEdgeAroundFaceCirculator< const Self >::idx_inner_half_edge_
HalfEdgeIndex idx_inner_half_edge_
Definition mesh_circulators.h:770
pcl::geometry::OuterHalfEdgeAroundFaceCirculator< const Self >::Mesh
const Self Mesh
Definition mesh_circulators.h:700
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::OuterHalfEdgeAroundFaceCirculator
OuterHalfEdgeAroundFaceCirculator()
Constructor resulting in an invalid circulator.
Definition mesh_circulators.h:705
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition mesh_circulators.h:761
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::operator==
bool operator==(const Self &other) const
Comparison operators (with boost::operators): == !=.
Definition mesh_circulators.h:731
pcl::geometry::OuterHalfEdgeAroundFaceCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition mesh_circulators.h:722
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator
Circulates counter-clockwise around a vertex and returns an index to the outgoing half-edge (the targ...
Definition mesh_circulators.h:174
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::getTargetIndex
HalfEdgeIndex getTargetIndex() const
Get the index to the outgoing half-edge.
Definition mesh_circulators.h:240
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< const Self >::Mesh
const Self Mesh
Definition mesh_circulators.h:182
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< const Self >::idx_outgoing_half_edge_
HalfEdgeIndex idx_outgoing_half_edge_
Definition mesh_circulators.h:256
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< const Self >::VertexIndex
typename Mesh::VertexIndex VertexIndex
Definition mesh_circulators.h:183
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< const Self >::mesh_
Mesh * mesh_
Definition mesh_circulators.h:253
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition mesh_circulators.h:247
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::OutgoingHalfEdgeAroundVertexCirculator
OutgoingHalfEdgeAroundVertexCirculator()
Constructor resulting in an invalid circulator.
Definition mesh_circulators.h:187
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::operator++
Self & operator++()
Increment operators (with boost::operators): ++ (pre and post).
Definition mesh_circulators.h:222
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< const Self >::Self
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< const Self > Self
Definition mesh_circulators.h:180
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition mesh_circulators.h:206
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:191
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::operator==
bool operator==(const Self &other) const
Comparison operators (with boost::operators): == !=.
Definition mesh_circulators.h:215
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:197
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator::operator--
Self & operator--()
Decrement operators (with boost::operators): – (pre and post).
Definition mesh_circulators.h:231
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< const Self >::HalfEdgeIndex
typename Mesh::HalfEdgeIndex HalfEdgeIndex
Definition mesh_circulators.h:184
pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< const Self >::Base
boost::equality_comparable< pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< const Self >, boost::unit_steppable< pcl::geometry::OutgoingHalfEdgeAroundVertexCirculator< const Self > > > Base
Definition mesh_circulators.h:176
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:491
pcl::geometry::VertexAroundFaceCirculator< const Self >::mesh_
Mesh * mesh_
Definition mesh_circulators.h:565
pcl::geometry::VertexAroundFaceCirculator< const Self >::Self
pcl::geometry::VertexAroundFaceCirculator< const Self > Self
Definition mesh_circulators.h:496
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:512
pcl::geometry::VertexAroundFaceCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition mesh_circulators.h:559
pcl::geometry::VertexAroundFaceCirculator::getTargetIndex
VertexIndex getTargetIndex() const
Get the index to the target vertex.
Definition mesh_circulators.h:552
pcl::geometry::VertexAroundFaceCirculator< const Self >::Base
boost::equality_comparable< pcl::geometry::VertexAroundFaceCirculator< const Self >, boost::unit_steppable< pcl::geometry::VertexAroundFaceCirculator< const Self > > > Base
Definition mesh_circulators.h:493
pcl::geometry::VertexAroundFaceCirculator::operator==
bool operator==(const Self &other) const
Comparison operators (with boost::operators): == !=.
Definition mesh_circulators.h:529
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:507
pcl::geometry::VertexAroundFaceCirculator< const Self >::Mesh
const Self Mesh
Definition mesh_circulators.h:498
pcl::geometry::VertexAroundFaceCirculator::operator++
Self & operator++()
Increment operators (with boost::operators): ++ (pre and post).
Definition mesh_circulators.h:536
pcl::geometry::VertexAroundFaceCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition mesh_circulators.h:520
pcl::geometry::VertexAroundFaceCirculator< const Self >::HalfEdgeIndex
typename Mesh::HalfEdgeIndex HalfEdgeIndex
Definition mesh_circulators.h:501
pcl::geometry::VertexAroundFaceCirculator::operator--
Self & operator--()
Decrement operators (with boost::operators): – (pre and post).
Definition mesh_circulators.h:544
pcl::geometry::VertexAroundFaceCirculator::VertexAroundFaceCirculator
VertexAroundFaceCirculator()
Constructor resulting in an invalid circulator.
Definition mesh_circulators.h:504
pcl::geometry::VertexAroundFaceCirculator< const Self >::idx_inner_half_edge_
HalfEdgeIndex idx_inner_half_edge_
Definition mesh_circulators.h:568
pcl::geometry::VertexAroundFaceCirculator< const Self >::VertexIndex
typename Mesh::VertexIndex VertexIndex
Definition mesh_circulators.h:499
pcl::geometry::VertexAroundFaceCirculator< const Self >::FaceIndex
typename Mesh::FaceIndex FaceIndex
Definition mesh_circulators.h:500
pcl::geometry::VertexAroundVertexCirculator
Circulates counter-clockwise around a vertex and returns an index to the terminating vertex of the ou...
Definition mesh_circulators.h:70
pcl::geometry::VertexAroundVertexCirculator< const Self >::mesh_
Mesh * mesh_
Definition mesh_circulators.h:146
pcl::geometry::VertexAroundVertexCirculator< const Self >::Mesh
const Self Mesh
Definition mesh_circulators.h:77
pcl::geometry::VertexAroundVertexCirculator::operator--
Self & operator--()
Decrement operators (with boost::operators): – (pre and post).
Definition mesh_circulators.h:124
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:90
pcl::geometry::VertexAroundVertexCirculator::operator++
Self & operator++()
Increment operators (with boost::operators): ++ (pre and post).
Definition mesh_circulators.h:115
pcl::geometry::VertexAroundVertexCirculator< const Self >::HalfEdgeIndex
typename Mesh::HalfEdgeIndex HalfEdgeIndex
Definition mesh_circulators.h:79
pcl::geometry::VertexAroundVertexCirculator::isValid
bool isValid() const
Check if the circulator is valid.
Definition mesh_circulators.h:99
pcl::geometry::VertexAroundVertexCirculator::getTargetIndex
VertexIndex getTargetIndex() const
Get the index to the target vertex.
Definition mesh_circulators.h:133
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:85
pcl::geometry::VertexAroundVertexCirculator< const Self >::Base
boost::equality_comparable< pcl::geometry::VertexAroundVertexCirculator< const Self >, boost::unit_steppable< pcl::geometry::VertexAroundVertexCirculator< const Self > > > Base
Definition mesh_circulators.h:72
pcl::geometry::VertexAroundVertexCirculator::VertexAroundVertexCirculator
VertexAroundVertexCirculator()
Constructor resulting in an invalid circulator.
Definition mesh_circulators.h:82
pcl::geometry::VertexAroundVertexCirculator< const Self >::VertexIndex
typename Mesh::VertexIndex VertexIndex
Definition mesh_circulators.h:78
pcl::geometry::VertexAroundVertexCirculator< const Self >::idx_outgoing_half_edge_
HalfEdgeIndex idx_outgoing_half_edge_
Definition mesh_circulators.h:149
pcl::geometry::VertexAroundVertexCirculator::getCurrentHalfEdgeIndex
HalfEdgeIndex getCurrentHalfEdgeIndex() const
Get the half-edge that is currently stored in the circulator.
Definition mesh_circulators.h:140
pcl::geometry::VertexAroundVertexCirculator::operator==
bool operator==(const Self &other) const
Comparison operators (with boost::operators): == !=.
Definition mesh_circulators.h:108
pcl::geometry::VertexAroundVertexCirculator< const Self >::Self
pcl::geometry::VertexAroundVertexCirculator< const Self > Self
Definition mesh_circulators.h:75
pcl::geometry::HalfEdgeIndex
pcl::detail::MeshIndex< struct HalfEdgeIndexTag > HalfEdgeIndex
Index used to access elements in the half-edge mesh.
Definition mesh_indices.h:199
pcl::geometry::FaceIndex
pcl::detail::MeshIndex< struct FaceIndexTag > FaceIndex
Index used to access elements in the half-edge mesh.
Definition mesh_indices.h:211
pcl::geometry::VertexIndex
pcl::detail::MeshIndex< struct VertexIndexTag > VertexIndex
Index used to access elements in the half-edge mesh.
Definition mesh_indices.h:193
pcl::geometry
Definition geometry.h:57
pcl
Definition convolution.h:46