OpenMesh.Core.Mesh.CirculatorsT

struct VertexVertexIterT (Mesh);

\class VertexVertexIterT CirculatorsT.hh Circulator.

VertexVertexIterT opCall ();

Default constructor

VertexVertexIterT opCall (Mesh _mesh, VertexHandle _start);

Construct with mesh and a VertexHandle

VertexVertexIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

VertexHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

int opApply (int delegate(ref value_handle) loop);

opApply to allow using in 'foreach'

struct ConstVertexVertexIterT (Mesh);

\class ConstVertexVertexIterT CirculatorsT.hh Circulator.

ConstVertexVertexIterT opCall ();

Default constructor

ConstVertexVertexIterT opCall (Mesh _mesh, VertexHandle _start);

Construct with mesh and a VertexHandle

ConstVertexVertexIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

ConstVertexVertexIterT* opAddAssign (uint i);

Pre-Increment (next cw target)

ConstVertexVertexIterT* opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

VertexHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

struct VertexOHalfedgeIterT (Mesh);

\class VertexOHalfedgeIterT CirculatorsT.hh Circulator.

VertexOHalfedgeIterT opCall ();

Default constructor

VertexOHalfedgeIterT opCall (Mesh _mesh, VertexHandle _start);

Construct with mesh and a VertexHandle

VertexOHalfedgeIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

VertexOHalfedgeIterT* opAddAssign (uint i);

Pre-Increment (next cw target)

VertexOHalfedgeIterT* opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

HalfedgeHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

int opApply (int delegate(ref value_handle) loop);

opApply to allow using in 'foreach'

struct ConstVertexOHalfedgeIterT (Mesh);

\class ConstVertexOHalfedgeIterT CirculatorsT.hh Circulator.

ConstVertexOHalfedgeIterT opCall ();

Default constructor

ConstVertexOHalfedgeIterT opCall (Mesh _mesh, VertexHandle _start);

Construct with mesh and a VertexHandle

ConstVertexOHalfedgeIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

HalfedgeHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

struct VertexIHalfedgeIterT (Mesh);

\class VertexIHalfedgeIterT CirculatorsT.hh Circulator.

VertexIHalfedgeIterT opCall ();

Default constructor

VertexIHalfedgeIterT opCall (Mesh _mesh, VertexHandle _start);

Construct with mesh and a VertexHandle

VertexIHalfedgeIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

HalfedgeHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

int opApply (int delegate(ref value_handle) loop);

opApply to allow using in 'foreach'

struct ConstVertexIHalfedgeIterT (Mesh);

\class ConstVertexIHalfedgeIterT CirculatorsT.hh Circulator.

ConstVertexIHalfedgeIterT opCall ();

Default constructor

ConstVertexIHalfedgeIterT opCall (Mesh _mesh, VertexHandle _start);

Construct with mesh and a VertexHandle

ConstVertexIHalfedgeIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

HalfedgeHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

struct VertexEdgeIterT (Mesh);

\class VertexEdgeIterT CirculatorsT.hh Circulator.

VertexEdgeIterT opCall ();

Default constructor

VertexEdgeIterT opCall (Mesh _mesh, VertexHandle _start);

Construct with mesh and a VertexHandle

VertexEdgeIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

EdgeHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

int opApply (int delegate(ref value_handle) loop);

opApply to allow using in 'foreach'

struct ConstVertexEdgeIterT (Mesh);

\class ConstVertexEdgeIterT CirculatorsT.hh Circulator.

ConstVertexEdgeIterT opCall ();

Default constructor

ConstVertexEdgeIterT opCall (Mesh _mesh, VertexHandle _start);

Construct with mesh and a VertexHandle

ConstVertexEdgeIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

EdgeHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

struct VertexFaceIterT (Mesh);

\class VertexFaceIterT CirculatorsT.hh Circulator.

VertexFaceIterT opCall ();

Default constructor

VertexFaceIterT opCall (Mesh _mesh, VertexHandle _start);

Construct with mesh and a VertexHandle

VertexFaceIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

FaceHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

int opApply (int delegate(ref value_handle) loop);

opApply to allow using in 'foreach'

struct ConstVertexFaceIterT (Mesh);

\class ConstVertexFaceIterT CirculatorsT.hh Circulator.

ConstVertexFaceIterT opCall ();

Default constructor

ConstVertexFaceIterT opCall (Mesh _mesh, VertexHandle _start);

Construct with mesh and a VertexHandle

ConstVertexFaceIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

FaceHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

struct FaceVertexIterT (Mesh);

\class FaceVertexIterT CirculatorsT.hh Circulator.

FaceVertexIterT opCall ();

Default constructor

FaceVertexIterT opCall (Mesh _mesh, FaceHandle _start);

Construct with mesh and a FaceHandle

FaceVertexIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

VertexHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

int opApply (int delegate(ref value_handle) loop);

opApply to allow using in 'foreach'

struct ConstFaceVertexIterT (Mesh);

\class ConstFaceVertexIterT CirculatorsT.hh Circulator.

ConstFaceVertexIterT opCall ();

Default constructor

ConstFaceVertexIterT opCall (Mesh _mesh, FaceHandle _start);

Construct with mesh and a FaceHandle

ConstFaceVertexIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

VertexHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

struct FaceHalfedgeIterT (Mesh);

\class FaceHalfedgeIterT CirculatorsT.hh Circulator.

FaceHalfedgeIterT opCall ();

Default constructor

FaceHalfedgeIterT opCall (Mesh _mesh, FaceHandle _start);

Construct with mesh and a FaceHandle

FaceHalfedgeIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

HalfedgeHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

int opApply (int delegate(ref value_handle) loop);

opApply to allow using in 'foreach'

struct ConstFaceHalfedgeIterT (Mesh);

\class ConstFaceHalfedgeIterT CirculatorsT.hh Circulator.

ConstFaceHalfedgeIterT opCall ();

Default constructor

ConstFaceHalfedgeIterT opCall (Mesh _mesh, FaceHandle _start);

Construct with mesh and a FaceHandle

ConstFaceHalfedgeIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

HalfedgeHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

struct FaceEdgeIterT (Mesh);

\class FaceEdgeIterT CirculatorsT.hh Circulator.

FaceEdgeIterT opCall ();

Default constructor

FaceEdgeIterT opCall (Mesh _mesh, FaceHandle _start);

Construct with mesh and a FaceHandle

FaceEdgeIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

EdgeHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

int opApply (int delegate(ref value_handle) loop);

opApply to allow using in 'foreach'

struct ConstFaceEdgeIterT (Mesh);

\class ConstFaceEdgeIterT CirculatorsT.hh Circulator.

ConstFaceEdgeIterT opCall ();

Default constructor

ConstFaceEdgeIterT opCall (Mesh _mesh, FaceHandle _start);

Construct with mesh and a FaceHandle

ConstFaceEdgeIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

EdgeHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

struct FaceFaceIterT (Mesh);

\class FaceFaceIterT CirculatorsT.hh Circulator.

FaceFaceIterT opCall ();

Default constructor

FaceFaceIterT opCall (Mesh _mesh, FaceHandle _start);

Construct with mesh and a FaceHandle

FaceFaceIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

FaceHandle handle ();

Return the handle of the current target.

value_type val ();

Return a reference to the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.

int opApply (int delegate(ref value_handle) loop);

opApply to allow using in 'foreach'

struct ConstFaceFaceIterT (Mesh);

\class ConstFaceFaceIterT CirculatorsT.hh Circulator.

ConstFaceFaceIterT opCall ();

Default constructor

ConstFaceFaceIterT opCall (Mesh _mesh, FaceHandle _start);

Construct with mesh and a FaceHandle

ConstFaceFaceIterT opCall (Mesh _mesh, HalfedgeHandle _heh);

Construct with mesh and start halfedge

void opAddAssign (uint i);

Pre-Increment (next cw target)

void opSubAssign (uint i);

Pre-Decrement (next ccw target)

HalfedgeHandle current_halfedge_handle ();

Get the current halfedge. There are \c Vertex*Iters and \c Face*Iters. For both the current state is defined by the current halfedge. This is what this method returns.

FaceHandle handle ();

Return the handle of the current target.

pointer ptr ();

Return a pointer to the current target.

bool is_active ();

Returns whether the circulator is still valid. After one complete round around a vertex/face the circulator becomes invalid, i.e. this function will return \c false. Nevertheless you can continue circulating. This method just tells you whether you have completed the first round.