CGAL.Polyhedron
 

 
Classes
       
Boost.Python.instance(__builtin__.object)
Edge_iterator
Facet
Facet_iterator
Halfedge
Halfedge_iterator
Plane_iterator
Point_iterator
Polyhedron_3
Vertex
Vertex_iterator

 
class Edge_iterator(Boost.Python.instance)
    
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)
    For a complete documentation see cgal user manual at:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Polyhedron_ref/Class_Polyhedron_3-Traits---Facet.html
 
 
Method resolution order:
Facet
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
__ne__(...)
facet_degree(...)
h.facet_degree( self ) -> int
the degree of the facet, i.e., number of edges on the boundary of this facet.
halfedge(...)
f.halfedge( self ) -> Halfedge
an incident halfedge that points to f.
is_quad(...)
h.is_quad( self ) -> bool
returns true if the facet is a quadrilateral.
is_triangle(...)
h.is_triangle( self ) -> bool
returns true if the facet is a triangle.
plane(...)
f.plane( self ) -> Plane_3
plane equation..
set_halfedge(...)
f.set_halfedge( self , Halfedge h) -> void
sets incident halfedge to h.
Precondition: h is incident, i.e., h.facet() == f.

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 Facet_iterator(Boost.Python.instance)
    
Method resolution order:
Facet_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 Halfedge(Boost.Python.instance)
    For a complete documentation see cgal user manual at:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Polyhedron_ref/Class_Polyhedron_3-Traits---Halfedge.html
 
 
Method resolution order:
Halfedge
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
__ne__(...)
facet(...)
h.facet( self ) ->  facet
the incident facet of h. If h is a border halfedge the result is default construction of the handle.
facet_degree(...)
h.facet_degree( self ) -> int
the degree of the incident facet, i.e., number of edges on the boundary of this facet.
is_bivalent(...)
h.is_bivalent( self ) -> bool
returns true if the incident vertex has exactly two incident edges.
is_border(...)
h.is_border( self ) -> bool
is true if h is a border halfedge.
is_border_edge(...)
h.is_border_edge( self ) -> bool
is true if h or h.opposite() is a border halfedge.
is_quad(...)
h.is_quad( self ) -> bool
returns true if the incident facet is a quadrilateral.
is_triangle(...)
h.is_triangle( self ) -> bool
returns true if the incident facet is a triangle.
is_trivalent(...)
h.is_trivalent( self ) -> bool
returns true if the incident vertex has exactly three incident edges.
next(...)
h.next( self ) -> Halfedge
the next halfedge around the facet.
next_on_vertex(...)
h.next_on_vertex( self ) -> Halfedge
the next halfedge around the vertex (clockwise).
Is equal to h.next().opposite().
opposite(...)
h.opposite( self ) -> Halfedge
the opposite halfedge.
prev(...)
h.prev( self ) -> Halfedge
the previous halfedge around the facet.
prev_on_vertex(...)
h.prev_on_vertex( self ) -> Halfedge
the previous halfedge around the vertex (counterclockwise).
Is equal to h.opposite().prev().
vertex(...)
h.vertex( self ) -> Vertex
the incident vertex of h.
vertex_degree(...)
h.vertex_degree( self ) -> int
the degree of the incident vertex, i.e., number of edges emanating from this vertex.

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 Halfedge_iterator(Boost.Python.instance)
    
Method resolution order:
Halfedge_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 Plane_iterator(Boost.Python.instance)
    
Method resolution order:
Plane_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)
    
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 Polyhedron_3(Boost.Python.instance)
    A polyhedral surface Polyhedron_3 consists of vertices V, edges E,
facets F and an incidence relation on them.
Creation:
P = Polyhedron_3()
the C++ documentation contains the wide explication of this class:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Polyhedron_ref/Class_Polyhedron_3.html
 
 
Method resolution order:
Polyhedron_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
add_facet_to_border(...)
P.add_facet_to_border( self , Halfedge h ,Halfedge g) -> Halfedge
creates a new facet within the hole incident to h and g by connecting 
the vertex denoted by g with the vertex denoted by h with a new halfedge 
and filling this separated part of the hole with a new facet, such that the
new facet is incident to g. Returns the halfedge of the new edge that is
incident to the new facet.
Precondition: h.is_border(), g.is_border(), h != g, h.next() != g, and g can
be reached along the same hole starting with h.
add_vertex_and_facet_to_border(...)
P.add_vertex_and_facet_to_border( self ,Halfedge h,Halfedge g) -> Halfedge
creates a new facet within the hole incident to h and g by connecting the 
tip of g with the tip of h with two new halfedges and a new vertex and filling
this separated part of the hole with a new facet, such that the new facet is
incident to g. Returns the halfedge of the new edge that is incident to the
new facet and the new vertex.
Precondition: h.is_border(), g.is_border(), h != g, and g can be reached 
along the same hole starting with h.
bytes(...)
P.bytes( self ) -> int
bytes used for the polyhedron.
bytes_reserved(...)
P.bytes_reserved( self ) -> int 
bytes reserved for the polyhedron.
capacity_of_facets(...)
P.capacity_of_facets( self ) -> int
space reserved for facets.
capacity_of_halfedges(...)
P.capacity_of_halfedges( self ) -> int
space reserved for halfedges.
capacity_of_vertices(...)
P.capacity_of_vertices( self ) -> int
space reserved for vertices.
clear(...)
P.clear( self) -> void
removes all vertices, halfedges, and facets.
create_center_vertex(...)
P.create_center_vertex( self , Halfedge h) -> Halfedge
barycentric triangulation of h.facet(). Creates a new vertex, a copy of
h.vertex(), and connects it to each vertex incident to h.facet() splitting
h->facet() into triangles. h remains incident to the original facet, all 
other triangles are copies of this facet. Returns the halfedge h.next() 
after the operation, i.e., a halfedge pointing to the new vertex. The time 
is proportional to the size of the facet.
Precondition: h is not a border halfedge.
empty(...)
P.empty( self ) -> bool
returns true if P is empty.
erase_all(...)
erase_center_vertex(...)
P.erase_center_vertex( self , Halfedge g) -> Halfedge
reverses create_center_vertex. Erases the vertex pointed to by g and all
incident halfedges thereby merging all incident facets. Only g.facet() 
remains. The neighborhood of g.vertex() may not be triangulated, it can 
have larger facets. Returns the halfedge g.prev(). Thus, the invariant 
h == erase_center_vertexcreate_center_vertex(h)) holds if h is not a 
border halfedge. The time is proportional to the sum of the size of all
incident facets.
Precondition: None of the incident facets of g.vertex() is a hole. 
There are at least two distinct facets incident to the facets that are
incident to g.vertex(). (This prevents the operation from collapsing a 
volume into two facets glued together with opposite orientations, such as
would happen with any vertex of a tetrahedron.)
erase_connected_component(...)
P.erase_connected_component( self , Halfedge h) -> void
removes the vertices, halfedges, and facets that belong to the connected
component of h.
erase_facet(...)
P.erase_facet( self , Halfedge h) -> void
removes the incident facet of h and changes all halfedges incident to the
facet into border edges or removes them from the polyhedral surface if they
were already border edges. If this creates isolated vertices they get removed
as well. See make_hole(h) for a more specialized variant. 
Precondition: h.is_border() == false.
fill_hole(...)
P.fill_hole( self, Halfedge h) -> Halfedge
fills a hole with a newly created facet. Makes all border halfedges of the
hole denoted by h incident to the new facet. Returns h.
Precondition: h.is_border().
flip_edge(...)
P.flip_edge( self , Halfedge h) -> Halfedge
performs an edge flip. It returns h after rotating the edge h one vertex 
in the direction of the face orientation.
Precondition: h != Halfedge() and both facets incident to h are triangles.
inside_out(...)
P.inside_out( self ) -> void
reverses facet orientations (incl. plane equations if supported).
is_closed(...)
P.is_closed( self) -> bool
returns true if there are no border edges.
is_pure_bivalent(...)
P.is_pure_bivalent( self) -> bool
returns true if all vertices have exactly two incident edges.
is_pure_quad(...)
P.is_pure_quad( self ) -> bool
returns true if all facets are quadrilaterals.
is_pure_triangle(...)
P.is_pure_triangle( self ) -> bool
returns true if all facets are triangles.
is_pure_trivalent(...)
P.is_pure_trivalent( self ) -> bool
returns true if all vertices have exactly three incident edges.
is_tetrahedron(...)
P.is_tetrahedron( self ,Halfedge h) -> bool
true iff the connected component denoted by h is a tetrahedron.
is_triangle(...)
P.is_triangle( self , Halfedge h) -> bool
true iff the connected component denoted by h is a triangle.
is_valid(...)
P.is_valid( self , bool verbose = false, int level = 0) -> bool
returns true if the polyhedral surface is combinatorially consistent. 
If verbose is true, statistics are printed to cerr. For level == 1 the 
normalization of the border edges is checked too. This method checks in 
particular level 3 of CGAL::Halfedge_data_structure_decorator::is_valid 
from page reference and that each facet is at least a triangle and that 
the two incident facets of a non-border edge are distinct.
join_facet(...)
P.join_facet( self ,Halfedge h) -> Halfedge
joins the two facets incident to h. 
The facet incident to h.opposite() gets removed. 
Both facets might be holes. 
Returns the predecessor of h around the facet. 
The invariant join_facetsplit_facet( h, g)) returns h and keeps 
the polyhedron unchanged. The time is proportional to the size of 
the facet removed and the time to compute h.prev().
Precondition: The degree of both vertices incident to h is at 
least three (no antennas).
Requirement: Supports_removal CGAL::Tag_true.
join_loop(...)
P.join_loop( self , Halfedge h, Halfedge g) -> Halfedge
glues the boundary of the two facets denoted by h and g together and returns
h. Both facets and the vertices along the facet denoted by g gets removed.
Both facets may be holes. The invariant join_loop( h, split_loop( h, i, j))
returns h and keeps the polyhedron unchanged.
Precondition: The facets denoted by h and g are different and have equal
degree (i.e., number of edges).
join_vertex(...)
P.join_vertex( self , Halfedge h) -> Halfedge
joins the two vertices incident to h. 
The vertex denoted by h.opposite() gets removed. 
Returns the predecessor of h around the vertex, i.e., h.opposite().prev().
The invariant join_vertexsplit_vertex( h, g)) returns h and keeps the
polyhedron unchanged.The time is proportional to the degree of the vertex
removed and the time to compute h.prev() and h.opposite().prev().
Precondition: The size of both facets incident to h is at least four
make_hole(...)
P.make_hole( self, Halfedge h) -> Halfedge
removes the incident facet of h and changes all halfedges incident to the
facet into border edges. Returns h.See erase_facet(h) for a more generalized variant.
Precondition: None of the incident halfedges of the facet is a border edge.
make_tetrahedron(...)
P.make_tetrahedron ( self) -> Halfedge
a tetrahedron is added to the polyhedral surface. 
Returns a halfedge of the tetrahedron.
 
P.make_tetrahedron( self,Point_3 p1,Point_3 p2,Point_3 p3,Point_3 p4) -> Halfedge
a tetrahedron is added to the polyhedral surface with its vertices
initialized to p1, p2, p3, and p4. 
Returns that halfedge of the tetrahedron which incident vertex is
initialized to p1. The incident vertex of the next halfedge is p2, 
and the vertex thereafter is p3. 
The remaining fourth vertex is initialized to p4.
make_triangle(...)
P.make_triangle( slef ) -> Halfedge
a triangle with border edges is added to the polyhedral surface. 
Returns a non-border halfedge of the triangle.
 
P.make_triangle( self ,Point_3 p1, Point_3 p2, Point_3 p3) -> Halfedge
a triangle with border edges is added to the polyhedral surface 
with its vertices initialized to p1, p2, and p3. 
Returns that non-border halfedge of the triangle which incident 
vertex is initialized to p1.
The incident vertex of the next halfedge is p2, and the vertex
thereafter is p3.
normalize_border(...)
normalized_border_is_valid(...)
P.normalized_border_is_valid( self , bool verbose = false) -> bool
returns true if the border halfedges are in normalized representation, which is
when enumerating all halfedges with the iterator: The non-border edges precede
the border edges and for border edges, the second halfedge is the border
halfedge. The halfedge iterator border_halfedges_begin() denotes the first border
edge. If verbose is true, statistics are printed to cerr.
reserve(...)
P.reserve ( self , int v, int h, int f) -> void
reserve storage for v vertices, h halfedges, and f facets. 
The reservation sizes are a hint for optimizing storage allocation. 
If the capacity is already greater than the requested size nothing happens.
size_of_border_edges(...)
P.size_of_border_edges( self ) -> int
number of border edges. Since each border edge of a polyhedral surface has
exactly one border halfedge, this number is equal to size_of_border_halfedges().
Precondition: last normalize_border() call still valid, see above.
size_of_border_halfedges(...)
P.size_of_border_halfedges( self ) -> int
number of border halfedges.
Precondition: last normalize_border() call still valid, see above.
size_of_facets(...)
P.size_of_facets( self ) -> int 
number of facets.
size_of_halfedges(...)
P.size_of_halfedges( self ) -> int 
number of halfedges (incl. border halfedges).
size_of_vertices(...)
P.size_of_vertices( self ) -> int 
number of vertices.
split_edge(...)
P.split_edge( self , Halfedge h) -> Halfedge
splits the halfedge h into two halfedges inserting a new vertex 
that is a copy of h.opposite().vertex(). 
Is equivalent to split_vertex( h.prev(), h.opposite()). 
The call of prev() can make this method slower than a direct call of
split_vertex() if the previous halfedge is already known and computing 
it would be costly when the halfedge data structure does not support the
prev() member function. Returns the new halfedge hnew pointing to the 
inserted vertex. The new halfedge is followed by the old halfedge, 
i.e., hnew->next() == h.
split_facet(...)
P.split_facet( self, Halfedge h, Halfedge g) -> Halfedge
splits the facet incident to h and g into two facets with a new 
diagonal between the two vertices denoted by h and g respectively. 
The second (new) facet is a copy of the first facet. 
Returns h.next() after the operation, i.e., the new diagonal. 
The new face is to the right of the new diagonal, the old face is 
to the left. The time is proportional to the distance from h to g 
around the facet.
Precondition: h and g are incident to the same facet. h != g .
h.next() != g and g.next() != h (no multi-edges).
split_loop(...)
P.split_loop( self , Halfedge h,Halfedge i,Halfedge j) -> Halfedge
cuts the polyhedron into two parts along the cycle (h,i,j) (edge j 
runs on the backside of the three dimensional figure above). Three new
vertices (one copy for each vertex in the cycle) and three new halfedges
(one copy for each halfedge in the cycle), and two new triangles are created.
h,i,j will be incident to the first new triangle. The return value will be 
the halfedge incident to the second new triangle which is the copy of h.opposite().
Precondition: h,i,j denote distinct, consecutive vertices of the polyhedron
and form a cycle: i.e., h.vertex() == i.opposite().vertex(), ...,
j.vertex() == h.opposite().vertex(). The six facets incident to h,i,j are 
all distinct.
split_vertex(...)
P.split_vertex( self , Halfedge h, Halfedge g) -> Halfedge
splits the vertex incident to h and g into two vertices, 
the old vertex remains and a new copy is created,and connects 
them with a new edge. Let hnew be h.next().opposite() after the 
split, i.e., a halfedge of the new edge. The split regroups the
halfedges around the two vertices. The halfedge sequence hnew,
g.next().opposite(), ..., h remains around the old vertex, while
the halfedge sequence hnew.opposite(), h.next().opposite() 
(before the split), ..., g is regrouped around the new vertex. 
The split returns hnew, i.e., the new halfedge incident to the old vertex. 
The time is proportional to the distance from h to g around the         vertex.
Precondition: h and g are incident to the same vertex. h != g (antennas are not allowed).
Note: A special application of the split is 
split_vertex(h.next().opposite()) which is equivalent to an edge 
split of the halfedge h->next() that creates a new vertex on the
halfedge h.next(). See also split_edge(h) below.

Properties defined here:
border_edges
get = (...)
border_halfedges
get = (...)
edges
get = (...)
facets
get = (...)
halfedges
get = (...)
planes
get = (...)
points
get = (...)
vertices
get = (...)

Data and other attributes defined here:
__instance_size__ = 64

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)
    A vertex optionally stores a point and a reference to an incident halfedge
that points to the vertex.
For mor details see a C++ doc:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Polyhedron_ref/Class_Polyhedron_3-Traits---Vertex.html
 
 
Method resolution order:
Vertex
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
__ne__(...)
halfedge(...)
v.halfedge( self) -> halfedge
an incident halfedge that points to v.
is_bivalent(...)
v.is_bivalent( self ) -> bool
returns true if the vertex has exactly two incident edges.
is_trivalent(...)
v.is_trivalent( self ) -> bool
returns true if the vertex has exactly three incident edges.
point(...)
v.point( self ) -> Point_3
Gets a point stored in the vertex v
set_halfedge(...)
v.set_halfedge( self , halfedge h) -> void
sets incident halfedge to h.
Precondition: h is incident, i.e., h.vertex() == v.
set_point(...)
v.set_point( self, Point_3 p) -> Sets the point p for the vertex v
vertex_degree(...)
v.vertex_degree( self ) -> int
the degree of the vertex, i.e., number of edges emanating from this vertex.

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)
    
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>