CGAL.Alpha_shapes_2
 

 
Classes
       
CGAL.Triangulations_2.Delaunay_triangulation_2(CGAL.Triangulations_2.Triangulation_2)
Alpha_shape_2
Boost.Python.instance(__builtin__.object)
Alpha_iterator
Alpha_shape_edges_iterator

 
class Alpha_iterator(Boost.Python.instance)
    Is an iterator that allow to traverse the increasing sequence of different alpha values.
 
 
Method resolution order:
Alpha_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 Alpha_shape_2(CGAL.Triangulations_2.Delaunay_triangulation_2)
    The class Alpha_shape_2 represents the family of alpha-shapes 
of points in a plan for all positive alpha. 
It maintains an underlying triangulation of the class 
Delaunay_triangulation_2 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_2_ref/Class_Alpha_shape_2.html
 
 
Method resolution order:
Alpha_shape_2
CGAL.Triangulations_2.Delaunay_triangulation_2
CGAL.Triangulations_2.Triangulation_2
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_2 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 ,Face f, alpha = get_alpha()) -> Classification_type
Classifies the face f of the underlying triangulation with respect to alpha.
 
A.classify( Self ,Edge e, alpha = get_alpha()) -> Classification_type
Classifies the edge e of the underlying triangulation with respect to alpha.
 
A.classify( Self ,Face f,int i,alpha = get_alpha()) -> Classification_type
Classifies the facet of the face 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_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.
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 = GENERAL) -> Mode
Sets A in GENERAL or REGULARIZED.Returns the previous mode.

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

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

Methods inherited from CGAL.Triangulations_2.Delaunay_triangulation_2:
dual(...)
dual(self, Face f) ->Point_2.
 
 Returns the center of the circle circumscribed to face f.
Precondition: f is not infinite.
 
dual(self,Edge e) ->returns a segment, a ray or a line supported by the bisector of the endpoints of e.
If faces incident to e are both finite, a segment whose endpoints are the duals of each incident face is returned. 
If only one incident face is finite, a ray whose endpoint is the dual of the finite incident face is returned.
Otherwise both incident faces are infinite and the bisector line is returned.
get_boundary_of_conflicts(...)
get_conflicts(...)
insert(...)
insert(self,Point_2 p,  Face f =  Face()) -> 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 is on an edge, the two incident faces are split in two.
If point p is strictly inside a face of the triangulation, the face is split in three.
If point p is strictly outside the convex hull, p is linked to all visible points on the convex hull to form the new triangulation.
At last, if p is outside the affine hull(in case of degenerate 1-dimensional or 0-dimensional triangulations),
p is linked all the other vertices to form a triangulation whose dimension is increased by one.
The last argument f is an indication to the underlying locate algorithm of where to start.
 
insert(self,Point_2 p,Locate_type lt, Face loc,int li) ->  Vertex.
 
Same as above except that the location of the point p to be inserted is assumed to be given by (lt,loc,i) 
 
insert(self,[p_1,...,p_n]) insert a list of Point_2.
is_valid(...)
nearest_vertex(...)
push_back(...)
push_back(self, Point_2 p) Equivalent to insert(p).
remove(...)
remove(self, Vertex v) -> void
 
Removes the vertex from the triangulation. The created hole is retriangulated.
Precondition: Vertex v must be finite.
side_of_oriented_circle(...)
t.side_of_oriented_circle(self, Face, Point_2) -> Oriented_side
Returns on which side of the circumcircle of face f lies the point p.
The circle is assumed to be counterclockwisely oriented, so its positive
side correspond to its bounded side. This predicate is available only if the
corresponding predicates on points is provided in the geometric traits class.

Methods inherited from CGAL.Triangulations_2.Triangulation_2:
circumcenter(...)
circumcenter(self,Face f,int i) -> Point_2 .
 
Compute the circumcenter of the face pointed to by f.
This function is available only if the correspoding function is provided in the geometric traits.
compare_x(...)
compare_y(...)
degree(...)
dimension(...)
dimension(self) -> int
Returns the dimension of the convex hull
finite_vertex(...)
finite_vertex(self) -> Vertex
 
a vertex distinct from the infinite_vertex.
flip(...)
flip(slef,Face f, int i) -> void 
 
Exchanges the edge incident to f and f->neighbor(i) with the other diagonal of the quadrilateral formed by f and f->neighbor(i).
Precondition: The faces f and f->neighbor(i) are finite faces and their union form a convex quadrilateral.
incident_edges(...)
incident_edges(self,Vertex v) -> Edge_circulator
 
Starts at an arbitrary edge incident to v.
incident_edges(self,Vertex v,Face f) -> Edge_circulator
 
Starts at the the first edge of f incident to v, in counterclockwise order around v.
Precondition: Face f is incident to vertex v.
incident_faces(...)
incident_faces(self,Vertex v) -> Face_circulator
 
Starts at an arbitrary face incident to v.
incident_faces(self,Vertex v,Face f) -> Face_circulator
 
Starts at face f.
Precondition: Face f is incident to vertex v.
incident_vertices(...)
incident_vertices(self,Vertex v) -> Vertex_circulator
 
Starts at an arbitrary vertex incident to v.
incident_vertices(self,Vertex v,Face f) -> Vertex_circulator
 
Starts at the first vertex of f adjacent to v in counterclockwise order around v.
Precondition: Face f is incident to vertex v.
includes_edge(...)
infinite_face(...)
infinite_face(self) -> Face
 
a face incident to the infinite_vertex.
infinite_tester(...)
infinite_tester(self) -> Infinite_tester
infinite_vertex(...)
infinite_vertex(self) -> Vertex
 
the infinite_vertex.
insert_first(...)
insert_first(self,Point_2 p) -> Vertex.
 
Inserts the first finite vertex .
insert_in_edge(...)
insert_in_edge(self,Point_2 p,Face f,int i) -> Vertex.
 
Inserts vertex v in edge i of f.
Precondition: The point in vertex v lies on the edge opposite to the vertex i of face f.
insert_in_face(...)
insert_in_face(self,Point_2 p,Face f) -> Vertex.
 
Inserts vertex v in face f. Face f is modified, two new faces are created.
Precondition: The point in vertex v lies inside face f. .
insert_outside_affine_hull(...)
insert_outside_convex_hull(...)
insert_outside_convex_hull(self,Point_2 p,Face f) -> Vertex.
 
Inserts a point which is outside the convex hull but in the affine hull.
Precondition: The handle f points to a face which is a proof of the location ofp, see the description of the locate method above.
 
insert_outside_convex_hull(self,Point_2 p) -> Vertex.
 
Inserts a point which is outside the affine hull.
insert_second(...)
insert_second(self,Point_2 p) -> Vertex.
 
Inserts the second finite vertex .
is_edge(...)
is_edge(slef,Vertex va, Vertex vb) -> bool
 
true if there is an edge having va and vb as vertices.
 
is_edge (self, Vertex va,Vertex vb,Edge e) -> bool
 
as above. In addition, if true is returned, the edge with vertices va and vb is the edge e 
where l[0] is a face incident to e and on the right side of e oriented from va to vb.
is_face(...)
is_face(self,Vertex v1,Vertex v2,Vertex v3) -> bool 
 
true if there is a face having v1, v2 and v3 as vertices.
 
is_face(self,Vertex v1,Vertex v2,Vertex v3,Face fr) -> bool 
 
as above. In addition, if true is returned, fr is a  face with v1, v2 and v3 as vertices.
is_infinite(...)
is_infinite(self,Vertex v) -> bool
 
true iff v is the infinite_vertex.
 
is_infinite(self,Face f) ->bool
 
true iff face f is infinite.
 
is_infinite(self,Face f, int i) -> bool
 
true iff edge(f,i) is infinite.
 
is_infinite(self,Edge e) -> bool
 
true iff edge e is infinite.
line_walk(...)
t.line_walk( self,Point_2 p,Point_2 q) -> list of faces
This function returns a list that allows to visit the faces intersected by the line pq.
If there is no such face the list is empty.
t.line_walk( self,Point_2 p,Point_2 q, Face f) -> list of faces
The starting point of the list is the face f
Precondition: Points p and q must be different points.
Precondition: If f is given, it must point to a finite face and the point p must be inside or on the boundary of f.
locate(...)
locate(self,Point_2 query, Face f = Face()) -> Face
 
If the point query lies inside the convex hull of the points, a face that contains the query in its interior or on its boundary is returned.
If the point query lies outside the convex hull of the triangulation but in the affine hull, the returned face is an infinite face which is a proof of the point's location :
- for a two dimensional triangulation, it is a face ( , p, q) such that query lies to the left of the oriented line pq (the rest of the triangulation lying to the right of this line).
- for a degenerate one dimensional triangulation it is the (degenarate one dimensional) face ( , p, NULL) such that query and the triangulation lie on either side of p.
If the point query lies outside the affine hull, the returned Face is None.The optional Face argument, if provided, is used as a hint of where the locate process has to start its search.
 
locate(self,Point_2 query,list l) -> Face
 
Same as above. Additionally, the parameters lt = l[0] and li=l[1] describe where the query point is located. The variable lt is set to the locate type of the query.
If lt==VERTEX the variable li is set to the index of the vertex, and if lt==EDGE li is set to the index of the vertex opposite to the edge. Be careful that li has no meaning when the query type is FACE,
OUTSIDE_CONVEX_HULL, or OUTSIDE_AFFINE_HULL or when the triangulation is 0-dimensional.
mirror_vertex(...)
number_of_faces(...)
number_of_faces(self) -> int
 
Returns the number of finite faces.
number_of_vertices(...)
number_of_vertices(self) -> int 
Returns the number of finite vertices.
oriented_side(...)
remove_degree_3(...)
remove_first(...)
remove_first(self,Vertex v) -> void.
 
Removes the last finite vertex.
remove_second(...)
remove_second(self,Vertex v) -> void.
 
Removes the before last finite vertex.
segment(...)
segment(self,Face f,int i) -> Segment_2 .
 
Returns the line segment formed by the vertices ccw(i) and cw(i) of face f.
Precondition: 0 <= i <= 2. The vertices ccw(i) and cw(i) of f are finite.
 
segment(self,Edge e) -> Segment_2 .
 
Returns the line segment corresponding to edge e.
Precondition: e is a finite edge
set_infinite_vertex(...)
swap(...)
swap (self,Triangulation_2)
t.swap(tr) 
The triangulations tr and t are swapped. t.swap(tr) should be preferred to t = tr or to t(tr).
triangle(...)
triangle(self,Face f) -> Triangle_2 .
 
Returns the triangle formed by the three vertices of f.
Precondition: The face is finite.
xy_equal(...)

Static methods inherited from CGAL.Triangulations_2.Triangulation_2:
ccw(...)
ccw(self,int i) -> Returns i+1 modulo 3. Precondition: 0 <= i <= 2.
cw(...)
cw(self,int i) -> Returns i+2 modulo 3. Precondition: 0 <= i <= 2.

Properties inherited from CGAL.Triangulations_2.Triangulation_2:
all_edges
get = (...)
all_faces
get = (...)
all_vertices
get = (...)
edges
get = (...)
faces
get = (...)
points
get = (...)
vertices
get = (...)

Data and other attributes inherited from CGAL.Triangulations_2.Triangulation_2:
Locate_type = <class 'CGAL.CGAL.Triangulations_2.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 Alpha_shape_edges_iterator(Boost.Python.instance)
    
Method resolution order:
Alpha_shape_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>