CGAL.Triangulations_3
 

 
Classes
       
Boost.Python.instance(__builtin__.object)
All_cells_iterator
All_edges_iterator
All_facets_iterator
All_vertices_iterator
Cell
Cell_circulator
Cell_iterator
Edge
Edge_iterator
Facet
Facet_circulator
Finite_facets_iterator
Point_iterator
Triangulation_3
Delaunay_triangulation_3
Vertex
Vertex_iterator

 
class All_cells_iterator(Boost.Python.instance)
    is an iterator over  all cells
 
 
Method resolution order:
All_cells_iterator
Boost.Python.instance
__builtin__.object

Methods defined here:
__iter__(...)
__len__(...)
next(...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class All_edges_iterator(Boost.Python.instance)
    is an iterator over all edges of the triangulation
 
 
Method resolution order:
All_edges_iterator
Boost.Python.instance
__builtin__.object

Methods defined here:
__iter__(...)
__len__(...)
next(...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class All_facets_iterator(Boost.Python.instance)
    is an iterator over  all facets of the triangulation
 
 
Method resolution order:
All_facets_iterator
Boost.Python.instance
__builtin__.object

Methods defined here:
__iter__(...)
__len__(...)
next(...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class All_vertices_iterator(Boost.Python.instance)
    is an iterator over  all vertices
 
 
Method resolution order:
All_vertices_iterator
Boost.Python.instance
__builtin__.object

Methods defined here:
__iter__(...)
__len__(...)
next(...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class Cell(Boost.Python.instance)
    This Class corresponds to the Cell_handle of cgal's C++ concept, 
it's not used directly, but related to the Trinagulations
 
 
Method resolution order:
Cell
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
__lt__(...)
__ne__(...)
has_neighbor(...)
c.has_neighbor( self ,Cell n) -> bool
Returns true if n is a neighbor of c.
has_vertex(...)
c.has_vertex( self ,Vertex v) -> bool
True iff v is a vertex of c.
index(...)
c.index( self , Cell n) -> int 
Returns the index of cell n in c.
Precondition: n is a neighbor of c.
 
c.index( self , Vertex v) -> int 
Returns the index of cell v in c.
neighbor(...)
c.neighbor( self ,int i) -> Cell
Returns the neighbor i of c.
Precondition: i belongs {0, 1, 2, 3}.
set_neighbor(...)
c.set_neighbor( self ,int i, Cell n) -> Sets neighbor i to n.
Precondition: i belongs to {0, 1, 2, 3}.
set_neighbors(...)
c.set_neighbors( self) -> Sets the neighbors to the default constructed handle.
set_vertex(...)
c.set_vertex( self ,int i, Vertex v) -> Sets vertex i to v.
Precondition: i belongs to {0, 1, 2, 3}.
set_vertices(...)
c.set_vertices( self) -> Sets the vertices to the default constructed Cell.
vertex(...)
c.vertex( self ,int i) -> Vertex
Returns the vertex i of c.
Precondition: i belongs to {0, 1, 2, 3}.
vertex_index(...)
c.vertex_index( self ,Vertex v) -> int 
Returns the index of v.
Precondition: v is a vertex of c

Data and other attributes defined here:
__instance_size__ = 12

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class Cell_circulator(Boost.Python.instance)
    is an iterator over a cells of the triangulation
No stop iteration.
 
 
Method resolution order:
Cell_circulator
Boost.Python.instance
__builtin__.object

Methods defined here:
__iter__(...)
next(...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class Cell_iterator(Boost.Python.instance)
    is an iterator over a finite cells
 
 
Method resolution order:
Cell_iterator
Boost.Python.instance
__builtin__.object

Methods defined here:
__iter__(...)
__len__(...)
next(...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class Delaunay_triangulation_3(Triangulation_3)
    The class Delaunay_triangulation_3 represents a three-dimensional Delaunay triangulation.
See a complete C++ documentation:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Triangulation_3_ref/Class_Delaunay_triangulation_3.html
 
 
Method resolution order:
Delaunay_triangulation_3
Triangulation_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
dual(...)
dt.dual( self, Cell c) -> Point_3
Returns the circumcenter of the four vertices of c.
Precondition: dt.dimension()=3 and c is not infinite.
 
dt.dual( self, Facet f) -> Returns the dual of facet f, which is
in dimension 3: either a segment, if the two cells incident to f are finite,
or a ray, if one of them is infinite;
in dimension 2: a point.
Precondition: dt.dimension() 2 and f is not infinite.
 
dt.dual( self, Cell c, int i) -> same as the previous method for facet (c,i).
find_conflicts(...)
dt.vertices_in_conflict ( self, Point_3 p,Cell_handle c) -> list of vertices
Similar to find_conflicts(), but reports the vertices which are on the boundary 
of the conflict hole of p
Precondition: dt.dimension() >= 2, and c is in conflict with p.
insert(...)
Same as Triangulation_3.insert
type help(Triangulation_3.insert)
is_Gabriel(...)
A face (cell, facet or edge) is said to be a Gabriel face iff its smallest
circumscribing sphere do not enclose any vertex of the triangulation. 
Any Gabriel face belongs to the Delaunay triangulation, but the reciprocal 
is not true. The following member functions test the Gabriel property of Delaunay faces.
dt.is_Gabriel( self, Cell c, int i) -> bool
 
dt.is_Gabriel( self, Cellc, int i, int j)-> bool
 
dt.is_Gabriel( self, Facet f) -> bool
 
dt.is_Gabriel( self, Edge e) -> bool
is_valid(...)
Same as Triangulation_3.is_valid
type help(Triangulation_3.is_valid)
move_point(...)
dt.move_point( self, Vertex v, Point_3 p) ->Vertex
Moves the point stored in v to p, while preserving the Delaunay property.
This performs an action semantically equivalent to remove(v) followed by insert(p), 
but is supposedly faster when the point has not moved much.
Precondition: v is a finite vertex of the triangulation.
nearest_vertex(...)
dt.nearest_vertex( self,Point p,Cell c = Cell()) -> Vertex
Returns any nearest vertex to the point p, or the default constructed
handle if the triangulation is empty. The optional argument c is a hint
specifying where to start the search.
Precondition: c is a cell of dt.
nearest_vertex_in_cell(...)
dt.nearest_vertex_in_cell( self, Point p, Cell c) ->Vertex
Returns the vertex of the cell c that is nearest to p.
remove(...)
dt.remove( self ,Vertex v) -> void
Removes the vertex v from the triangulation.
Precondition: v is a finite vertex of the triangulation.
side_of_circle(...)
dt.side_of_circle ( self,Facet f, Point_3 p) -> Bounded_side
Returns a value indicating on which side of the circumscribed circle of f the point p lies. 
More precisely, it returns:
- in dimension 3:
- For a finite facet, ON_BOUNDARY if p lies on the circle, 
  ON_UNBOUNDED_SIDE when it lies in the exterior of the disk,
  ON_BOUNDED_SIDE when it lies in its interior.
- For an infinite facet, it considers the plane defined by the finite
  facet of the same cell, and does the same as in dimension 2 in this plane.
- in dimension 2:
- For a finite facet, ON_BOUNDARY if p lies on the circle, 
  ON_UNBOUNDED_SIDE when it lies in the exterior of the disk, 
  ON_BOUNDED_SIDE when it lies in its interior.
- For an infinite facet, ON_BOUNDARY if the point lies on 
  the finite edge of f (endpoints included), ON_BOUNDED_SIDE 
  for a point in the open half plane defined by f and not containing
  any other point of the triangulation, ON_UNBOUNDED_SIDE elsewhere.
Precondition: dt.dimension() >= 2 and in dimension 3, p is coplanar with f.
dt.side_of_circle( self, Cell c, int i, Point p) -> Bounded_side
Same as the previous method for facet i of cell c.
side_of_sphere(...)
dt.side_of_sphere( self, Cell c, Point p) -> Bounded_side 
Returns a value indicating on which side of the circumscribed sphere of c the point p lies. More precisely, it returns:
- ON_BOUNDED_SIDE if p is inside the sphere.
For an infinite cell this means that p lies strictly either in 
the half space limited by its finite facet and not containing any 
other point of the triangulation, or in the interior of the disk circumscribing the finite facet.
- ON_BOUNDARY if p on the boundary of the sphere. 
For an infinite cell this means that p lies on the circle circumscribing the finite facet.
- ON_UNBOUNDED_SIDE if p lies outside the sphere. 
For an infinite cell this means that p does not satisfy either of the two previous conditions.
Precondition: dt.dimension() =3.
vertices_in_conflict(...)
dt.vertices_in_conflict ( self, Point_3 p,Cell_handle c) -> list of vertices
Similar to find_conflicts(), but reports the vertices which are on the boundary 
of the conflict hole of p
Precondition: dt.dimension() >= 2, and c is in conflict with p.

Data and other attributes defined here:
__instance_size__ = 96

Methods inherited from Triangulation_3:
__eq__(...)
__ne__(...)
are_equal(...)
t.are_equal( self ,Cell c,int i,Cell n,int j) -> bool
 
t.are_equal( self ,Facet f, Facet g) -> bool
 
t.are_equal( self ,Facet f, Cell n, int j) -> bool
For these three methods:
Precondition: t.dimension()=3.
clear(...)
t.clear( slef ) -> Deletes all finite vertices and all cells of t.
degree(...)
t.degree( self ,Vertex v) -> int
Returns the degree of a vertex, that is, the number of incident vertices. 
The infinite vertex is counted.
Precondition: v Vertex(), t.is_vertex(v).
dimension(...)
t.dimension( slef )  -> int
Returns the dimension of the affine hull.
flip(...)
t.flip( self,Edge e) -> bool
 
t.flip( self,Cell c, int i, int j) -> bool
Before flipping, these methods check that edge e=(c,i,j) is flippable
(which is quite expensive). They return false or true according to this test.
 
t.flip( self,Facet f) -> bool
 
t.flip( self,Cell c, int i) -> bool
Before flipping, these methods check that facet f=(c,i) is flippable 
(which is quite expensive). They return false or true according to this test.
has_vertex(...)
incident_cells(...)
t.incident_cells( self,Edge e) -> Cell_circulator
Starts at an arbitrary cell incident to e.
Precondition: t.dimension() =3.
 
t.incident_cells( self, Cell c, int i, int j) -> Cell_circulator
As above for edge (i,j) of c.
 
t.incident_cells( self, Edge e, Cell start) -> Cell_circulator
Starts at cell start.
Precondition: t.dimension() =3 and start is incident to e.
 
t.incident_cells( self, Cell c,int i,int j,Cell start) -> Cell_circulator
As above for edge (i,j) of c.
 
t.incident_cells( self, Vertex v) -> list of cells
Returns a list of all cells incident to v.
If t.dimension() <3, then do nothing. 
Returns the resulting iterator.
Precondition: v # Vertex(), t.is_vertex(v).
incident_facets(...)
t.incident_facets( self , Edge e) -> Facet_circulator
Starts at an arbitrary facet incident to e.
Precondition: t.dimension() =3
 
t.incident_facets( self , Cell c,int i,int j) -> Facet_circulator
As above for edge (i,j) of c.
 
t.incident_facets( self , Edge e,Facet start) -> Facet_circulator
Starts at facet start.
Precondition: start is incident to e.
 
t.incident_facets( self , Edge e , Cell start ,int f) -> Facet_circulator
Starts at facet of index f in start.
 
t.incident_facets( self, Cell c,int i,int j,Facet start) -> Facet_circulator
As above for edge (i,j) of c.
 
t.incident_facets( self , Cell c,int i,int j,Cell start,int f)-> Facet_circulator
As above for edge (i,j) of c and facet (start,f).
 
t.incident_facets (self,Vertex v) -> list of facets
Returns a list of all the Facets incident to v.
Precondition: t.dimension()=3, v # Vertex(), t.is_vertex(v).
incident_vertices(...)
t.incident_vertices( self , Vertex v) -> list of vertices
Returns a list of all vertices incident to v. 
If t.dimension() <2, then do nothing. 
Returns the resulting iterator.
Precondition: v # Vertex(), t.is_vertex(v).
infinite_cell(...)
t.infinite_cell( self ) -> Cell
Returns a cell incident to the infinite vertex.
infinite_vertex(...)
t.infinite_vertex( self ) -> Vertex
Returns the infinite vertex.
insert_in_cell(...)
t.insert_in_cell( self ,Point_3 p, Cell c) -> Vertex
Inserts point p in cell c. Cell c is split into 4 tetrahedra.
Precondition: t.dimension() =3 and p lies strictly inside cell c.
insert_in_edge(...)
t.insert_in_edge( self ,Point_3 p, Edge e) -> Vertex
Inserts p in edge e. In dimension 3, 
all the cells having this edge are split into 2 tetrahedra; 
in dimension 2, the 2 neighboring facets are split into 2 triangles; 
in dimension 1, the edge is split into 2 edges.
Precondition: t.dimension() 1 and p lies on edge e.
 
t.insert_in_edge( self ,Point_3 p, Cell c, int i,int j) -> Vertex
As above, inserts p in edge (i, j) of c.
Precondition: As above and i # j. Moreover i,j belongs to {0,1,2,3} in dimension 3,
i,j belongs to {0,1,2} in dimension 2, i,j belongs to {0,1} in dimension 1.
insert_in_facet(...)
t.insert_in_facet( self ,Point_3 p, Facet f) -> Vertex
Inserts point p in facet f. In dimension 3, 
the 2 neighboring cells are split into 3 tetrahedra; 
in dimension 2, the facet is split into 3 triangles.
Precondition: t.dimension() 2 and p lies strictly inside face f.
 
t.insert_in_facet( self ,Point_3 p, Cell c, int i) -> Vertex
As above, insertion in facet (c,i).
Precondition: As above and i belongs to {0,1,2,3} in dimension 3, i = 3 in dimension 2.
insert_in_hole(...)
t.insert_in_hole(self,Point_3 p ,list_of_cells l,Cell c,int i) -> Vertex
Creates a new vertex by starring a hole. 
It takes a list of cells l which specifies a hole: a set of connected cells
(resp. facets in dimension 2) which is star-shaped wrt p.
insert_outside_affine_hull(...)
t.insert_outside_affine_hull( self ,Point_3 p) -> Vertex
p is linked to all the points, and the infinite vertex is linked 
to all the points (including p) to triangulate the new infinite face, 
so that all the points now belong to the boundary of the convex hull.
This method can be used to insert the first point in an empty triangulation.
Precondition: t.dimension() <3 and p lies outside the affine hull of the points.
insert_outside_convex_hull(...)
t.insert_outside_convex_hull( self,Point_3 p, Cell c) -> Vertex
The cell c must be an infinite cell containing p.
Links p to all points in the triangulation that are visible from p.
Updates consequently the infinite faces. See Figure 22.9.
Precondition: t.dimension() >0, c, and the k-face represented by c 
is infinite and contains t.
is_cell(...)
t.is_cell( self , Cell c) -> bool
Tests whether c is a cell of t.
 
is_cell( self , Vertex u,Vertex v,Vertex w,Vertex x,Cell c) -> bool
Tests whether (u,v,w,x) is a cell of t and computes this cell c.
Precondition: u, v, w and x are vertices of t.
is_edge(...)
t.is_edge( self , Vertex u,Vertex v,Cell c,Edge e) -> bool
Tests whether (u,v) is an edge of t and computes this edge e.
Precondition: u and v are vertices of t.
is_facet(...)
t.is_facet( self , Vertex u,Vertex v,Vertex w,Cell c,list l) -> bool
Tests whether (u,v,w) is a facet of t. If the facet is found, 
it gives a cell c having this facet and the list l of indices of 
the vertices u ,v and w in c, in this order.
Precondition: u ,v and w are vertices of t.
is_infinite(...)
t.is_infinite( self ,Vertex v ) -> bool
true, iff vertex v is the infinite vertex.
 
t.is_infinite( slef,const Cell c) -> bool
true, iff c is incident to the infinite vertex.
Precondition: t.dimension() =3.
 
t.is_infinite( self, Cell c, int i) -> bool
true, iff the facet i of cell c is incident to the infinite vertex.
Precondition: t.dimension() >= 2 and i belongs to {0,1,2,3} in dimension 3, i=3 in dimension 2.
 
t.is_infinite( self , Facet f) -> bool
true iff facet f is incident to the infinite vertex.
Precondition: t.dimension() 2.
 
t.is_infinite( self , Cell c, int i, int j) -> bool
true, iff the edge (i,j) of cell c is incident to the infinite vertex.
Precondition: t.dimension() 1 and i # j. Moreover i,j belongs to {0,1,2,3} in dimension 3,
i,j belongs to {0,1,2} in dimension 2, i,j belongs to {0,1} in dimension 1.
 
t.is_infinite( self , Edge e) -> bool 
true iff edge e is incident to the infinite vertex.
Precondition: t.dimension() >= 1.
is_vertex(...)
t.is_vertex( self ,Point p, Vertex  v) -> bool
Tests whether p is a vertex of t by locating p in the triangulation.
If p is found, the associated vertex v is given.
 
t.is_vertex( self ,Vertex v) -> bool
Tests whether v is a vertex of t.
locate(...)
t.locate( self, Point_3 query,Cell start = Cell()) ->Cell
If the point query lies inside the convex hull of the points, 
the cell that contains the query in its interior is returned. 
If query lies on a facet, an edge or on a vertex, one of the 
cells having query on its boundary is returned.
If the point query lies outside the convex hull of the points, 
an infinite cell with vertices { p, q, r, } is returned such that
the tetrahedron ( p, q, r, query ) is positively oriented 
(the rest of the triangulation lies on the other side of facet ( p, q, r )).
Note that locate works even in degenerate dimensions: in dimension 2 
(resp. 1, 0) the Cell returned is the one that represents the facet 
(resp. edge, vertex) containing the query point.
The optional argument start is used as a starting place for the search.
 
t.locate( self, Point_3 query,list [lt,li,lj]) ->Cell
If query lies inside the affine hull of the points,
the k-face (finite or infinite) that contains query in its interior is returned,
by means of the cell returned together with lt, 
which is set to the locate type of the query 
(VERTEX, EDGE, FACET, CELL, or OUTSIDE_CONVEX_HULL if the cell is 
infinite and query lies strictly in it) and two indices li and lj that 
specify the k-face of the cell containing query.
If the k-face is a cell, li and lj have no meaning; 
if it is a facet (resp. vertex), li gives the index of the facet 
(resp. vertex) and lj has no meaning; if it is and edge, 
li and lj give the indices of its vertices.
If the point query lies outside the affine hull of the points,
which can happen in case of degenerate dimensions, 
lt is set to OUTSIDE_AFFINE_HULL, and the cell returned has no meaning.
As a particular case, if there is no finite vertex yet in the triangulation,
lt is set to OUTSIDE_AFFINE_HULL and locate returns the default constructed handle.
number_of_cells(...)
t.number_of_cells( self) -> int
Returns the number of cells or 0 if t.dimension()<3.
number_of_edges(...)
t.number_of_edges( self) -> int
The number of edges. Returns 0 if t.dimension()<1.
number_of_facets(...)
t.number_of_facets( slef ) -> int
The number of facets. Returns 0 if t.dimension()<2.
number_of_finite_cells(...)
t.number_of_finite_cells( slef) -> int
The number of finite cells. Returns 0 if t.dimension()<3.
number_of_finite_edges(...)
t.number_of_finite_edges( self) -> int
The number of finite edges. Returns 0 if t.dimension()<1.
number_of_finite_facets(...)
t.number_of_finite_facets( self) -> int
The number of finite facets. Returns 0 if t.dimension()<2.
number_of_vertices(...)
t.number_of_vertices( slef ) -> int 
Returns the number of finite vertices.
segment(...)
t.segment( self, Edge e) -> Segment_3
Returns the line segment formed by the vertices of e.
Precondition: t.dimension() 1 and e is finite.
 
t.segment( self, Cell c, int i, int j) -> Segment_3
Same as the previous method for edge (c,i,j).
Precondition: As above and i j. Moreover i,j belongs to {0,1,2,3} in dimension 3,
i,j belongs to {0,1,2} in dimension 2, i,j belongs to {0,1} in dimension 1.
side_of_cell(...)
t.side_of_cell( self ,Point p,Cell c,List [lt,li,lj]) -> Bounded_side
Returns a value indicating on which side of the oriented boundary of c the point p lies.
More precisely, it returns:
- ON_BOUNDED_SIDE if p is inside the cell. For an infinite cell
this means that p lies strictly in the half space limited 
by its finite facet and not containing any other point of the triangulation.
- ON_BOUNDARY if p on the boundary of the cell. 
For an infinite cell this means that p lies on the finite facet. 
Then lt together with li and lj give the precise location on the boundary.
(See the descriptions of the locate methods.)
- ON_UNBOUNDED_SIDE if p lies outside the cell. 
For an infinite cell this means that p does not satisfy either of the two previous conditions.
Precondition: t.dimension() =3
side_of_edge(...)
t.side_of_edge( self ,Point p,Edge e,List [lt,li]) -> Bounded_side
Returns a value indicating on which side of the oriented boundary of f the point p lies.
More precisely, it returns:
- ON_BOUNDED_SIDE if p is inside the edge.
For an infinite edge this means that p lies in the half line defined
by the vertex and not containing any other point of the triangulation.
- ON_BOUNDARY if p equals one of the vertices,li give the index of
the vertex in the cell storing e
(See the descriptions of the locate methods.)
- ON_UNBOUNDED_SIDE if p lies outside the edge. For an infinite edge this means that p lies on the other half line, which contains the other points of the triangulation.
Precondition: t.dimension() =1 and p is collinear with the points of the
triangulation. e.second =0 and e.third =1 (in dimension 1 there is only one edge per cell)
 
t.side_of_edge( self ,Point p,Cell c,List [lt,li]) -> Bounded_side
Same as the previous method for edge(c,0,1).
side_of_facet(...)
t.side_of_facet( self ,Point p,Facet c,List [lt,li,lj]) -> Bounded_side
Returns a value indicating on which side of the oriented boundary of f the point p lies.
More precisely, it returns:
- ON_BOUNDED_SIDE if p is inside the facet. For an infinite facet
this means that p lies strictly in the half space limited 
by its finite facet and not containing any other point of the triangulation.
- ON_BOUNDARY if p on the boundary of the facet. 
For an infinite facet this means that p lies on the finite facet. 
Then lt together with li and lj give the precise location on the boundary.
(See the descriptions of the locate methods.)
- ON_UNBOUNDED_SIDE if p lies outside the facet. 
For an infinite facet this means that p does not satisfy either of the two previous conditions.
Precondition: t.dimension() =2 and p lies in the plane containing the
triangulation. f.second =3 (in dimension 2 there is only one facet per cell).
 
t.side_of_facet( self ,Point p,Cell c,List [lt,li,lj]) -> Bounded_side
Same as the previous method for the facet (c,3).
swap(...)
t.swap ( self, Triangulation_3 tr ) 
The triangulations tr and t are swapped.
t.swap(tr ) should be preferred to t = tr or to t(tr) if tr is deleted after that.
Indeed, there is no copy of cells and vertices, thus this method runs in constant time.
tetrahedron(...)
t.tetrahedron( self, Cell c) -> Tetrahedron_3
Returns the tetrahedron formed by the four vertices of c.
Precondition: t.dimension() =3 and the cell is finite.
triangle(...)
t.triangle( self , Cell c, int i) -> Triangle_3
Returns the triangle formed by the three vertices of facet (c,i). 
The triangle is oriented so that its normal points to the inside of cell c.
Precondition: t.dimension() 2 and i belongs to {0,1,2,3} in dimension 3, 
i = 3 in dimension 2, and the facet is finite.
 
t.triangle( self , Facet f ) -> Triangle_3
Same as the previous method for facet f.
Precondition: t.dimension() >= 2 and the facet is finite.

Properties inherited from Triangulation_3:
all_cells
get = (...)
all_edges
get = (...)
all_facets
get = (...)
all_vertices
get = (...)
cells
get = (...)
edges
get = (...)
facets
get = (...)
points
get = (...)
vertices
get = (...)

Data and other attributes inherited from Triangulation_3:
Locate_type = <class 'CGAL.CGAL.Triangulations_3.Locate_type'>

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class Edge(Boost.Python.instance)
    
Method resolution order:
Edge
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
cell(...)
e.cell( Self) -> Cell
Returns the cell of the Edge e
index(...)
e.index( self ,int i) -> int
Returns the indices of the Edge e
Precondition: i belongs to {0,1}

Data and other attributes defined here:
__instance_size__ = 20

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class Edge_iterator(Boost.Python.instance)
    is an iterator over a finite edges of the triangulation
 
 
Method resolution order:
Edge_iterator
Boost.Python.instance
__builtin__.object

Methods defined here:
__iter__(...)
__len__(...)
next(...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class Facet(Boost.Python.instance)
    
Method resolution order:
Facet
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
__ne__(...)
cell(...)
f.cell( Self) -> Cell
Returns the cell of the facet f
vertex_index(...)
e.vertex_index( self ) -> int
Returns the vertex index of the facet f

Data and other attributes defined here:
__instance_size__ = 16

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class Facet_circulator(Boost.Python.instance)
    is an iterator over a facets of the triangulation
No stop iteration.
 
 
Method resolution order:
Facet_circulator
Boost.Python.instance
__builtin__.object

Methods defined here:
__iter__(...)
next(...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class Finite_facets_iterator(Boost.Python.instance)
    is an iterator over a finite facets of the triangulation
 
 
Method resolution order:
Finite_facets_iterator
Boost.Python.instance
__builtin__.object

Methods defined here:
__iter__(...)
__len__(...)
next(...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class Point_iterator(Boost.Python.instance)
    is an iterator over a points of the triangulation
 
 
Method resolution order:
Point_iterator
Boost.Python.instance
__builtin__.object

Methods defined here:
__iter__(...)
__len__(...)
next(...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class Triangulation_3(Boost.Python.instance)
    The class Triangulation_3 represents a 3-dimensional tetrahedralization of points.
For more details see:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Triangulation_3_ref/Class_Triangulation_3.html
 
 
Method resolution order:
Triangulation_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
__ne__(...)
are_equal(...)
t.are_equal( self ,Cell c,int i,Cell n,int j) -> bool
 
t.are_equal( self ,Facet f, Facet g) -> bool
 
t.are_equal( self ,Facet f, Cell n, int j) -> bool
For these three methods:
Precondition: t.dimension()=3.
clear(...)
t.clear( slef ) -> Deletes all finite vertices and all cells of t.
degree(...)
t.degree( self ,Vertex v) -> int
Returns the degree of a vertex, that is, the number of incident vertices. 
The infinite vertex is counted.
Precondition: v Vertex(), t.is_vertex(v).
dimension(...)
t.dimension( slef )  -> int
Returns the dimension of the affine hull.
flip(...)
t.flip( self,Edge e) -> bool
 
t.flip( self,Cell c, int i, int j) -> bool
Before flipping, these methods check that edge e=(c,i,j) is flippable
(which is quite expensive). They return false or true according to this test.
 
t.flip( self,Facet f) -> bool
 
t.flip( self,Cell c, int i) -> bool
Before flipping, these methods check that facet f=(c,i) is flippable 
(which is quite expensive). They return false or true according to this test.
has_vertex(...)
incident_cells(...)
t.incident_cells( self,Edge e) -> Cell_circulator
Starts at an arbitrary cell incident to e.
Precondition: t.dimension() =3.
 
t.incident_cells( self, Cell c, int i, int j) -> Cell_circulator
As above for edge (i,j) of c.
 
t.incident_cells( self, Edge e, Cell start) -> Cell_circulator
Starts at cell start.
Precondition: t.dimension() =3 and start is incident to e.
 
t.incident_cells( self, Cell c,int i,int j,Cell start) -> Cell_circulator
As above for edge (i,j) of c.
 
t.incident_cells( self, Vertex v) -> list of cells
Returns a list of all cells incident to v.
If t.dimension() <3, then do nothing. 
Returns the resulting iterator.
Precondition: v # Vertex(), t.is_vertex(v).
incident_facets(...)
t.incident_facets( self , Edge e) -> Facet_circulator
Starts at an arbitrary facet incident to e.
Precondition: t.dimension() =3
 
t.incident_facets( self , Cell c,int i,int j) -> Facet_circulator
As above for edge (i,j) of c.
 
t.incident_facets( self , Edge e,Facet start) -> Facet_circulator
Starts at facet start.
Precondition: start is incident to e.
 
t.incident_facets( self , Edge e , Cell start ,int f) -> Facet_circulator
Starts at facet of index f in start.
 
t.incident_facets( self, Cell c,int i,int j,Facet start) -> Facet_circulator
As above for edge (i,j) of c.
 
t.incident_facets( self , Cell c,int i,int j,Cell start,int f)-> Facet_circulator
As above for edge (i,j) of c and facet (start,f).
 
t.incident_facets (self,Vertex v) -> list of facets
Returns a list of all the Facets incident to v.
Precondition: t.dimension()=3, v # Vertex(), t.is_vertex(v).
incident_vertices(...)
t.incident_vertices( self , Vertex v) -> list of vertices
Returns a list of all vertices incident to v. 
If t.dimension() <2, then do nothing. 
Returns the resulting iterator.
Precondition: v # Vertex(), t.is_vertex(v).
infinite_cell(...)
t.infinite_cell( self ) -> Cell
Returns a cell incident to the infinite vertex.
infinite_vertex(...)
t.infinite_vertex( self ) -> Vertex
Returns the infinite vertex.
insert(...)
t.insert( self,Point_3 p, Cell start = Cell()) -> Vertex
Inserts point p in the triangulation and returns the corresponding vertex.
If point p coincides with an already existing vertex, this vertex is returned 
and the triangulation remains unchanged.
If point p lies in the convex hull of the points, it is added naturally: 
if it lies inside a cell, the cell is split into four cells, if it lies on a facet, 
the two incident cells are split into three cells, if it lies on an edge, all 
the cells incident to this edge are split into two cells.
If point p is strictly outside the convex hull but in the affine hull, p is linked
to all visible points on the convex hull to form the new triangulation.
If point p is outside the affine hull of the points, p is linked to all the points, 
and the dimension of the triangulation is incremented.
All the points now belongs to the boundary of the convex hull, so, the infinite vertex 
is linked to all the points to triangulate the new infinite face.
The optional argument start is used as a starting place for the search.
 
t.insert( self,Point p,Locate_type lt,Cell loc,int li,int lj) -> Vertex
Inserts point p in the triangulation and returns the corresponding vertex. 
Similar to the above insert() function, but takes as additional parameter 
the return values of a previous location query.
 
t.insert( self,list l) -> Vertex
Inserts a list l of points in the triangulation and returns the number of inserted points.
insert_in_cell(...)
t.insert_in_cell( self ,Point_3 p, Cell c) -> Vertex
Inserts point p in cell c. Cell c is split into 4 tetrahedra.
Precondition: t.dimension() =3 and p lies strictly inside cell c.
insert_in_edge(...)
t.insert_in_edge( self ,Point_3 p, Edge e) -> Vertex
Inserts p in edge e. In dimension 3, 
all the cells having this edge are split into 2 tetrahedra; 
in dimension 2, the 2 neighboring facets are split into 2 triangles; 
in dimension 1, the edge is split into 2 edges.
Precondition: t.dimension() 1 and p lies on edge e.
 
t.insert_in_edge( self ,Point_3 p, Cell c, int i,int j) -> Vertex
As above, inserts p in edge (i, j) of c.
Precondition: As above and i # j. Moreover i,j belongs to {0,1,2,3} in dimension 3,
i,j belongs to {0,1,2} in dimension 2, i,j belongs to {0,1} in dimension 1.
insert_in_facet(...)
t.insert_in_facet( self ,Point_3 p, Facet f) -> Vertex
Inserts point p in facet f. In dimension 3, 
the 2 neighboring cells are split into 3 tetrahedra; 
in dimension 2, the facet is split into 3 triangles.
Precondition: t.dimension() 2 and p lies strictly inside face f.
 
t.insert_in_facet( self ,Point_3 p, Cell c, int i) -> Vertex
As above, insertion in facet (c,i).
Precondition: As above and i belongs to {0,1,2,3} in dimension 3, i = 3 in dimension 2.
insert_in_hole(...)
t.insert_in_hole(self,Point_3 p ,list_of_cells l,Cell c,int i) -> Vertex
Creates a new vertex by starring a hole. 
It takes a list of cells l which specifies a hole: a set of connected cells
(resp. facets in dimension 2) which is star-shaped wrt p.
insert_outside_affine_hull(...)
t.insert_outside_affine_hull( self ,Point_3 p) -> Vertex
p is linked to all the points, and the infinite vertex is linked 
to all the points (including p) to triangulate the new infinite face, 
so that all the points now belong to the boundary of the convex hull.
This method can be used to insert the first point in an empty triangulation.
Precondition: t.dimension() <3 and p lies outside the affine hull of the points.
insert_outside_convex_hull(...)
t.insert_outside_convex_hull( self,Point_3 p, Cell c) -> Vertex
The cell c must be an infinite cell containing p.
Links p to all points in the triangulation that are visible from p.
Updates consequently the infinite faces. See Figure 22.9.
Precondition: t.dimension() >0, c, and the k-face represented by c 
is infinite and contains t.
is_cell(...)
t.is_cell( self , Cell c) -> bool
Tests whether c is a cell of t.
 
is_cell( self , Vertex u,Vertex v,Vertex w,Vertex x,Cell c) -> bool
Tests whether (u,v,w,x) is a cell of t and computes this cell c.
Precondition: u, v, w and x are vertices of t.
is_edge(...)
t.is_edge( self , Vertex u,Vertex v,Cell c,Edge e) -> bool
Tests whether (u,v) is an edge of t and computes this edge e.
Precondition: u and v are vertices of t.
is_facet(...)
t.is_facet( self , Vertex u,Vertex v,Vertex w,Cell c,list l) -> bool
Tests whether (u,v,w) is a facet of t. If the facet is found, 
it gives a cell c having this facet and the list l of indices of 
the vertices u ,v and w in c, in this order.
Precondition: u ,v and w are vertices of t.
is_infinite(...)
t.is_infinite( self ,Vertex v ) -> bool
true, iff vertex v is the infinite vertex.
 
t.is_infinite( slef,const Cell c) -> bool
true, iff c is incident to the infinite vertex.
Precondition: t.dimension() =3.
 
t.is_infinite( self, Cell c, int i) -> bool
true, iff the facet i of cell c is incident to the infinite vertex.
Precondition: t.dimension() >= 2 and i belongs to {0,1,2,3} in dimension 3, i=3 in dimension 2.
 
t.is_infinite( self , Facet f) -> bool
true iff facet f is incident to the infinite vertex.
Precondition: t.dimension() 2.
 
t.is_infinite( self , Cell c, int i, int j) -> bool
true, iff the edge (i,j) of cell c is incident to the infinite vertex.
Precondition: t.dimension() 1 and i # j. Moreover i,j belongs to {0,1,2,3} in dimension 3,
i,j belongs to {0,1,2} in dimension 2, i,j belongs to {0,1} in dimension 1.
 
t.is_infinite( self , Edge e) -> bool 
true iff edge e is incident to the infinite vertex.
Precondition: t.dimension() >= 1.
is_valid(...)
t.is_valid( self, bool verbose = false) -> bool
Checks the combinatorial validity of the triangulation. 
Checks also the validity of its geometric embedding (see Section 22.1).
When verbose is set to true, messages describing the first invalidity 
encountered are printed.
 
t.is_valid( self, Cell c, bool verbose = false) -> bool
Checks the combinatorial validity of the cell by calling the is_valid 
method of the TriangulationDataStructure_3 cell class. Also checks the 
geometric validity of c, if c is finite.
When verbose is set to true, messages are printed to give a precise 
indication of the kind of invalidity encountered.
is_vertex(...)
t.is_vertex( self ,Point p, Vertex  v) -> bool
Tests whether p is a vertex of t by locating p in the triangulation.
If p is found, the associated vertex v is given.
 
t.is_vertex( self ,Vertex v) -> bool
Tests whether v is a vertex of t.
locate(...)
t.locate( self, Point_3 query,Cell start = Cell()) ->Cell
If the point query lies inside the convex hull of the points, 
the cell that contains the query in its interior is returned. 
If query lies on a facet, an edge or on a vertex, one of the 
cells having query on its boundary is returned.
If the point query lies outside the convex hull of the points, 
an infinite cell with vertices { p, q, r, } is returned such that
the tetrahedron ( p, q, r, query ) is positively oriented 
(the rest of the triangulation lies on the other side of facet ( p, q, r )).
Note that locate works even in degenerate dimensions: in dimension 2 
(resp. 1, 0) the Cell returned is the one that represents the facet 
(resp. edge, vertex) containing the query point.
The optional argument start is used as a starting place for the search.
 
t.locate( self, Point_3 query,list [lt,li,lj]) ->Cell
If query lies inside the affine hull of the points,
the k-face (finite or infinite) that contains query in its interior is returned,
by means of the cell returned together with lt, 
which is set to the locate type of the query 
(VERTEX, EDGE, FACET, CELL, or OUTSIDE_CONVEX_HULL if the cell is 
infinite and query lies strictly in it) and two indices li and lj that 
specify the k-face of the cell containing query.
If the k-face is a cell, li and lj have no meaning; 
if it is a facet (resp. vertex), li gives the index of the facet 
(resp. vertex) and lj has no meaning; if it is and edge, 
li and lj give the indices of its vertices.
If the point query lies outside the affine hull of the points,
which can happen in case of degenerate dimensions, 
lt is set to OUTSIDE_AFFINE_HULL, and the cell returned has no meaning.
As a particular case, if there is no finite vertex yet in the triangulation,
lt is set to OUTSIDE_AFFINE_HULL and locate returns the default constructed handle.
number_of_cells(...)
t.number_of_cells( self) -> int
Returns the number of cells or 0 if t.dimension()<3.
number_of_edges(...)
t.number_of_edges( self) -> int
The number of edges. Returns 0 if t.dimension()<1.
number_of_facets(...)
t.number_of_facets( slef ) -> int
The number of facets. Returns 0 if t.dimension()<2.
number_of_finite_cells(...)
t.number_of_finite_cells( slef) -> int
The number of finite cells. Returns 0 if t.dimension()<3.
number_of_finite_edges(...)
t.number_of_finite_edges( self) -> int
The number of finite edges. Returns 0 if t.dimension()<1.
number_of_finite_facets(...)
t.number_of_finite_facets( self) -> int
The number of finite facets. Returns 0 if t.dimension()<2.
number_of_vertices(...)
t.number_of_vertices( slef ) -> int 
Returns the number of finite vertices.
segment(...)
t.segment( self, Edge e) -> Segment_3
Returns the line segment formed by the vertices of e.
Precondition: t.dimension() 1 and e is finite.
 
t.segment( self, Cell c, int i, int j) -> Segment_3
Same as the previous method for edge (c,i,j).
Precondition: As above and i j. Moreover i,j belongs to {0,1,2,3} in dimension 3,
i,j belongs to {0,1,2} in dimension 2, i,j belongs to {0,1} in dimension 1.
side_of_cell(...)
t.side_of_cell( self ,Point p,Cell c,List [lt,li,lj]) -> Bounded_side
Returns a value indicating on which side of the oriented boundary of c the point p lies.
More precisely, it returns:
- ON_BOUNDED_SIDE if p is inside the cell. For an infinite cell
this means that p lies strictly in the half space limited 
by its finite facet and not containing any other point of the triangulation.
- ON_BOUNDARY if p on the boundary of the cell. 
For an infinite cell this means that p lies on the finite facet. 
Then lt together with li and lj give the precise location on the boundary.
(See the descriptions of the locate methods.)
- ON_UNBOUNDED_SIDE if p lies outside the cell. 
For an infinite cell this means that p does not satisfy either of the two previous conditions.
Precondition: t.dimension() =3
side_of_edge(...)
t.side_of_edge( self ,Point p,Edge e,List [lt,li]) -> Bounded_side
Returns a value indicating on which side of the oriented boundary of f the point p lies.
More precisely, it returns:
- ON_BOUNDED_SIDE if p is inside the edge.
For an infinite edge this means that p lies in the half line defined
by the vertex and not containing any other point of the triangulation.
- ON_BOUNDARY if p equals one of the vertices,li give the index of
the vertex in the cell storing e
(See the descriptions of the locate methods.)
- ON_UNBOUNDED_SIDE if p lies outside the edge. For an infinite edge this means that p lies on the other half line, which contains the other points of the triangulation.
Precondition: t.dimension() =1 and p is collinear with the points of the
triangulation. e.second =0 and e.third =1 (in dimension 1 there is only one edge per cell)
 
t.side_of_edge( self ,Point p,Cell c,List [lt,li]) -> Bounded_side
Same as the previous method for edge(c,0,1).
side_of_facet(...)
t.side_of_facet( self ,Point p,Facet c,List [lt,li,lj]) -> Bounded_side
Returns a value indicating on which side of the oriented boundary of f the point p lies.
More precisely, it returns:
- ON_BOUNDED_SIDE if p is inside the facet. For an infinite facet
this means that p lies strictly in the half space limited 
by its finite facet and not containing any other point of the triangulation.
- ON_BOUNDARY if p on the boundary of the facet. 
For an infinite facet this means that p lies on the finite facet. 
Then lt together with li and lj give the precise location on the boundary.
(See the descriptions of the locate methods.)
- ON_UNBOUNDED_SIDE if p lies outside the facet. 
For an infinite facet this means that p does not satisfy either of the two previous conditions.
Precondition: t.dimension() =2 and p lies in the plane containing the
triangulation. f.second =3 (in dimension 2 there is only one facet per cell).
 
t.side_of_facet( self ,Point p,Cell c,List [lt,li,lj]) -> Bounded_side
Same as the previous method for the facet (c,3).
swap(...)
t.swap ( self, Triangulation_3 tr ) 
The triangulations tr and t are swapped.
t.swap(tr ) should be preferred to t = tr or to t(tr) if tr is deleted after that.
Indeed, there is no copy of cells and vertices, thus this method runs in constant time.
tetrahedron(...)
t.tetrahedron( self, Cell c) -> Tetrahedron_3
Returns the tetrahedron formed by the four vertices of c.
Precondition: t.dimension() =3 and the cell is finite.
triangle(...)
t.triangle( self , Cell c, int i) -> Triangle_3
Returns the triangle formed by the three vertices of facet (c,i). 
The triangle is oriented so that its normal points to the inside of cell c.
Precondition: t.dimension() 2 and i belongs to {0,1,2,3} in dimension 3, 
i = 3 in dimension 2, and the facet is finite.
 
t.triangle( self , Facet f ) -> Triangle_3
Same as the previous method for facet f.
Precondition: t.dimension() >= 2 and the facet is finite.

Properties defined here:
all_cells
get = (...)
all_edges
get = (...)
all_facets
get = (...)
all_vertices
get = (...)
cells
get = (...)
edges
get = (...)
facets
get = (...)
points
get = (...)
vertices
get = (...)

Data and other attributes defined here:
Locate_type = <class 'CGAL.CGAL.Triangulations_3.Locate_type'>
__instance_size__ = 96

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class Vertex(Boost.Python.instance)
    This Class corresponds to the Vertex_handle of cgal's C++ concept, 
it's not used directly, but returned by many functions of the Trinagulation 
classes like in the insertion of points
 
 
Method resolution order:
Vertex
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
__lt__(...)
__ne__(...)
cell(...)
v.cell( self) -> Cell
Returns the incident cell
info(...)
Returns the object stored in the vertex.
is_valid(...)
v.is_valid( self, bool verbose = False) ->bool
Performs any desired test on a vertex. 
Checks that the pointer to an incident cell is not the default constructed handle.
point(...)
v.point( self) -> Point_3
Returns the point.
set_cell(...)
v.set_cell( self, Cell c) -> Sets the incident cell
set_info(...)
sets the info of Vertex, the info type could be any python object
set_point(...)
v.set_point( self , Point_3 p) -> Sets the point.

Data and other attributes defined here:
__instance_size__ = 12

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>

 
class Vertex_iterator(Boost.Python.instance)
    is an iterator over a finite vertices
 
 
Method resolution order:
Vertex_iterator
Boost.Python.instance
__builtin__.object

Methods defined here:
__iter__(...)
__len__(...)
next(...)

Data and other attributes defined here:
__init__ = <built-in function __init__>
Raises an exception
This class cannot be instantiated from Python

Data and other attributes inherited from Boost.Python.instance:
__dict__ = <dictproxy object>
__new__ = <built-in method __new__ of Boost.Python.class object>
T.__new__(S, ...) -> a new object with type S, a subtype of T
__weakref__ = <member '__weakref__' of 'Boost.Python.instance' objects>