CGAL.Alpha_shapes_3
 

 
Classes
       
CGAL.Triangulations_3.Delaunay_triangulation_3(CGAL.Triangulations_3.Triangulation_3)
Alpha_shape_3
Boost.Python.instance(__builtin__.object)
OutputItCells
OutputItEdges
OutputItFacets
OutputItVertices

 
class Alpha_shape_3(CGAL.Triangulations_3.Delaunay_triangulation_3)
    The class Alpha_shape_3 represents the family of alpha shapes 
of points in the 3D space for all positive . 
It maintains an underlying triangulation of the class 
Delaunay_triangulation_3 Dt which represents connectivity and 
order among its faces. Each k-dimensional face of the Dt is associated
with an interval that specifies for which values of  the face belongs to the alpha shape.
for more details See:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Alpha_shapes_3_ref/Class_Alpha_shape_3.html
 
 
Method resolution order:
Alpha_shape_3
CGAL.Triangulations_3.Delaunay_triangulation_3
CGAL.Triangulations_3.Triangulation_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
alpha_find(...)
A.alpha_find( self ,alpha) -> Alpha_iterator
Returns an iterator pointing to an element with alpha-value alpha,
or the corresponding past-the-end iterator if such an element is not found.
to get the value of the returned iterator, use the next() function:
it = A.alpha_find(2) ; value_of_alpha = it.next()
alpha_lower_bound(...)
A.alpha_lower_bound( self , alpha) -> Alpha_iterator
Returns an iterator pointing to the first element with alpha-value 
not less than alpha.
to get the value of the returned iterator,use the next() function
alpha_upper_bound(...)
A.alpha_upper_bound( self , alpha) -> Alpha_iterator
Returns an iterator pointing to the first element with 
alpha-value greater than alpha.
to get the value of the returned iterator, use the next() function.
classify(...)
A.classify( Self ,Point_3 p, alpha = get_alpha()) -> Classification_type
Locates a point p in the underlying triangulation and Classifies 
the associated k-face with respect to alpha.
 
A.classify( Self ,Cell f, alpha = get_alpha()) -> Classification_type
Classifies the cell f of the underlying triangulation with respect to alpha.
 
A.classify( Self ,Facet f, alpha = get_alpha()) -> Classification_type
Classifies the facet e of the underlying triangulation with respect to alpha.
 
A.classify( Self ,Cell f,int i,alpha = get_alpha()) -> Classification_type
Classifies the facet of the cell f opposite to the vertex with index i of 
the underlying triangulation with respect to alpha.
 
A.classify( Self ,Edge e, alpha = get_alpha()) -> Classification_type
Classifies the edge e with respect to alpha .
 
A.classify( Self ,Vertex v, alpha = get_alpha()) -> Classification_type
Classifies the vertex v of the underlying triangulation with respect to alpha.
clear(...)
A.clear( slef) -> Clears the structure.
find_optimal_alpha(...)
A.find_optimal_alpha( self , int nb_components) -> Alpha_iterator
Returns an iterator pointing to smallest value such that A satisfies 
the following two properties:
all data points are either on the boundary or in the interior of the 
regularized version of A.
The number of solid component of A is equal to or smaller than nb_components.
get_alpha(...)
get_alpha( slef ) -> double
Returns the current alpha-value.
get_alpha_shape_cells(...)
A.get_alpha_shape_cells( self ,Classification_type type, double alpha = get_alpha()) -> OutputItCells
Write the cells which are of type type for the alpha value alpha.
get_alpha_shape_edges(...)
A.get_alpha_shape_edges( self ,Classification_type type,double alpha = get_alpha()) -> OutputItEdges
Write the edges which are of type type for the alpha value alpha.
get_alpha_shape_facets(...)
A.get_alpha_shape_cells ( self,Classification_type type, double alpha = get_alpha()) -> OutputItFacets
Write the facets which are of type for the alpha value alpha.
get_alpha_shape_vertices(...)
A.get_alpha_shape_vertices ( self ,Classification_type type, alphaget_alpha()) -> OutputItVertices
Write the vertices which are of type type for the alpha value alpha
get_mode(...)
A.get_mode( self) -> Mode
Returns whether A is general or regularized.
get_nth_alpha(...)
A.get_nth_alpha( self , int n) -> double
Returns the n-th alpha-value, sorted in an increasing order.
Precondition: n < number of alphas.
make_alpha_shape(...)
A.make_alpha_shape( self , list L) -> int
Initialize the alpha shape data structure for points in the list L. 
Returns the number of data points inserted in the underlying triangulation.
If the function is applied to an non-empty alpha shape data structure,
it is cleared before initialization.
number_of_alphas(...)
A.number_of_alphas( self) -> int 
Returns the number of different alpha-values.
number_of_solid_components(...)
A.number_of_solid_components( slef , double alpha = get_alpha()) -> int
Returns the number of solid components of A, that is, 
the number of components of its regularized version.
print_alpha_status(...)
print_alphas(...)
print_maps(...)
set_alpha(...)
A.set_alpha( self ,alpha) -> double
Sets the alpha-value to alpha. Returns the previous alpha-value.
Precondition: alpha >= 0.
set_mode(...)
A.set_mode( self , Mode m = REGULARIZED) -> Mode
Sets A in GENERAL or REGULARIZED.Returns the previous mode. 
Changing the mode of an alpha shape data structure entails a partial 
recomputation of the data structure.

Properties defined here:
alpha
get = (...)

Data and other attributes defined here:
Classification_type = <class 'CGAL.CGAL.Alpha_shapes_3.Classification_type'>
Mode = <class 'CGAL.CGAL.Alpha_shapes_3.Mode'>
__instance_size__ = 296

Methods inherited from CGAL.Triangulations_3.Delaunay_triangulation_3:
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.

Methods inherited from CGAL.Triangulations_3.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.
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 CGAL.Triangulations_3.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 CGAL.Triangulations_3.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 OutputItCells(Boost.Python.instance)
    
Method resolution order:
OutputItCells
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 OutputItEdges(Boost.Python.instance)
    
Method resolution order:
OutputItEdges
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 OutputItFacets(Boost.Python.instance)
    
Method resolution order:
OutputItFacets
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 OutputItVertices(Boost.Python.instance)
    
Method resolution order:
OutputItVertices
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>