CGAL.Kernel
 

 
Classes
       
Boost.Python.instance(__builtin__.object)
Aff_transformation_2
Aff_transformation_3
Circle_2
Direction_2
Direction_3
Identity_transformation
Iso_rectangle_2
Line_2
Line_3
Null_vector
Origin
Plane_3
Point_2
Point_3
Ray_2
Ray_3
Reflection
Rotation
Scaling
Segment_2
Segment_3
Sphere_3
Tetrahedron_3
Translation
Triangle_2
Triangle_3
Vector_2
Vector_3

 
class Aff_transformation_2(Boost.Python.instance)
    The class Aff_transformation_2 represents two-dimensioanl affine transformations. 
The general form of an affine transformation is based on a homogeneous representation of points. 
Thereby all transformations can be realized by matrix multiplications.
For more information see a C++ doc:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Aff_transformation_2.html
 
 
Method resolution order:
Aff_transformation_2
Boost.Python.instance
__builtin__.object

Methods defined here:
__call__(...)
t( Point_2 p) -> Point_2
 
t( Vector_2 v) -> Vector_2
 
t( Direction_2 d) -> Direction_2
 
t( Line_2 l) -> Line_2
__init__(...)
t = Aff_transformation_2Identity_transformation)
introduces an identity transformation.
 
t = Aff_transformation_2TranslationVector_2 v)
introduces a translation by a vector v.
 
t = Aff_transformation_2Rotation,Direction_2 d,num,den = 1)
approximates the rotation over the angle indicated by direction d, 
such that the differences between the sines and cosines of the rotation
given by d and the approximating rotation are at most num/den each.
Precondition: num/den > 0.
 
t = Aff_transformation_2Rotation,sine_rho,cosine_rho,hw = 1)
introduces a rotation by the angle rho.
Precondition: sine_rho**2 + cosine_rho**2 == hw2.
 
t = Aff_transformation_2Scaling,s,hw = 1)
introduces a scaling by a scale factor s/hw.
 
t = Aff_transformation_2( m00,m01,m02,m10,m11,m12,hw = 1)
introduces a general affine transformation in the 3x3 matrix
|m00 m01 m02|
|m00 m00 m00|
|0   0   hw |
 
t = Aff_transformation_2( m00,m01,m10,m11,hw = 1)
introduces a general linear transformation in the 3x3 matrix
__mul__(...)
cartesian(...)
t.cartesian (int i,int j) -> m(i,j) of t
hm(...)
t.hm (int i,int j) -> double
returns entry mij in some fixed matrix representation.
homogeneous(...)
t.homogeneous (int i,int j) -> hm(i,j) of t
inverse(...)
t.inverse () -> Aff_transformation_2
gives the inverse transformation.
is_even(...)
t.is_even () -> bool
returns true, if the transformation is not reflecting, i.e. 
the determinant of the involved linear transformation is non-negative.
is_odd(...)
t.is_odd () -> bool
returns true, if the transformation is reflecting.
m(...)
t.m (int i,int j) -> double
returns entry mij in a matrix representation in which m22 is 1.
transform(...)
t.transform ( Point_2 p) -> Point_2
 
t.transform ( Vector_2 v) -> Vector_2
 
t.transform ( Direction_2 d) -> Direction_2
 
t.transform ( Line_2 l) -> Line_2

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 Aff_transformation_3(Boost.Python.instance)
    The class Aff_transformation_3 represents three-dimensioanl affine transformations. 
The general form of an affine transformation is based on a homogeneous representation of points. 
Thereby all transformations can be realized by matrix multiplications.
For more information see a C++ doc:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Aff_transformation_3.html
 
 
Method resolution order:
Aff_transformation_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__call__(...)
t( Point_2 p) -> Point_2
 
t( Vector_2 v) -> Vector_2
 
t( Direction_2 d) -> Direction_2
 
t( Line_2 l) -> Line_2
__init__(...)
t = Aff_transformation_2Identity_transformation)
introduces an identity transformation.
 
t = Aff_transformation_2TranslationVector_3 v)
introduces a translation by a vector v.
 
t = Aff_transformation_2Scaling,s,hw = 1)
introduces a scaling by a scale factor s/hw.
 
t = Aff_transformation_2(  m00,m01,m02,m03,m10,m11,m13,m20,m21,m23,hw = 1)
introduces a general affine transformation of the matrix form
|m00 m01 m02 m03|
|m10 m11 m12 m13|
|m20 m21 m22 m23|
|0   0   0   hw |
 
t = Aff_transformation_2( m00,m01,m02,m10,m11,m12,m20,m21,m22,hw = 1)
introduces a general linear transformation of the matrix form
__mul__(...)
cartesian(...)
t.cartesian (int i,int j) -> m(i,j) of t
hm(...)
t.hm (int i,int j) -> double
returns entry mij in some fixed matrix representation.
homogeneous(...)
t.homogeneous (int i,int j) -> hm(i,j) of t
inverse(...)
t.inverse () -> Aff_transformation_2
gives the inverse transformation.
is_even(...)
t.is_even () -> bool
returns true, if the transformation is not reflecting, i.e. 
the determinant of the involved linear transformation is non-negative.
is_odd(...)
t.is_odd () -> bool
returns true, if the transformation is reflecting.
m(...)
t.m (int i,int j) -> double
returns entry mij in a matrix representation in which m33 is 1.
transform(...)
t.transform ( Point_3 p) -> Point_3
 
t.transform ( Vector_3 v) -> Vector_3
 
t.transform ( Direction_3 d) -> Direction_3
 
t.transform ( Plane_3 p) -> Plane_3

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 Circle_2(Boost.Python.instance)
    An object of type Circle_2 is a circle in the two-dimensional Euclidean plane. 
The circle is oriented, i.e. its boundary has clockwise or counterclockwise orientation . 
The boundary splits E x E into a positive and a negative side, 
where the positive side is to the left of the boundary. 
The boundary also splits E x E into a bounded and an unbounded side. 
Note that the circle can be degenerated, i.e. the squared radius may be zero.
For more details see a C++ doc:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Circle_2.html
 
 
Method resolution order:
Circle_2
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
c = Circle_2Point_2 center,squared_radius,Orientation ori = COUNTERCLOCKWISE)introduces a variable c of type Circle_2
It is initialized to the circle with center center, squared radius squared_radius and orientation ori.
Precondition: ori COLLINEAR, and further, squared_radius 0.
 
c = Circle_2Point_2 p,Point_2 q,Point_2 r);
introduces a variable c of type Circle_2
It is initialized to the unique circle which passes through the points p, q and r. 
The orientation of the circle is the orientation of the point triple p, q, r.
Precondition: p, q, and r are not collinear.
 
c = Circle_2Point_2 p,Point_2 q,Orientation ori = COUNTERCLOCKWISE)
 
introduces a variable c of type Circle_2. It is initialized to the circle with diameter pq and orientation ori.
Precondition: ori COLLINEAR.
c = Circle_2Point_2 center,Orientation ori = COUNTERCLOCKWISE)
introduces a variable c of type Circle_2
It is initialized to the circle with center center, squared radius zero and orientation ori.
Precondition: ori COLLINEAR.
Postcondition: c.is_degenerate() = true.
__ne__(...)
bbox(...)
bounded_side(...)
c.bounded_side(self, Point_2 p) -> Bounded_side
returns ON_BOUNDED_SIDE, ON_BOUNDARY, 
or ON_UNBOUNDED_SIDE  iff p lies properly inside, on the boundary, or properly outside of c, resp.
center(...)
c.center(self) ->Point_2
returns the center of c.
has_on_boundary(...)
c.has_on_boundary(self , Point_2 p) -> bool
has_on_bounded_side(...)
c.has_on_bounded_side(self , Point_2 p) -> bool
has_on_negative_side(...)
c.has_on_positive_side(self , Point_2 p) -> bool
has_on_positive_side(...)
c.is_degenerate(self) -> bool
returns true, iff c is degenerate, i.e. if c has squared radius zero.
has_on_unbounded_side(...)
c.has_on_negative_side(self , Point_2 p) -> bool
is_degenerate(...)
c.opposite(self) -> Circle_2
returns the circle with the same center and squared radius as c but with opposite orientation .
opposite(...)
c.bbox(self) -> Bbox_2
returns a bounding box containing c.
orientation(...)
c.orientation(self) -> Orientation
returns the orientation of c.
oriented_side(...)
c.oriented_side(self ,Point_2 p) ->Oriented_side
returns either the constant ON_ORIENTED_BOUNDARY, ON_POSITIVE_SIDE, 
or ON_NEGATIVE_SIDE, iff p lies on the boundary, properly on 
the positive side, or properly on the negative side of c, resp.
squared_radius(...)
c.squared_radius(self) ->double
returns the squared radius of c.

Data and other attributes defined here:
__instance_size__ = 36

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 Direction_2(Boost.Python.instance)
    An object of the class Direction_2 is a vector in the two-dimensional vector space RxR where we forget about its length.
They can be viewed as unit vectors, although there is no normalization internally, since this is error prone.
Directions are used whenever the length of a vector does not matter.
 They also characterize a set of parallel oriented lines that have the same orientations.
For example, you can ask for the direction orthogonal to an oriented plane, or the direction of an oriented line.
Further, they can be used to indicate angles. The slope of a direction is dy()/dx().
For more details see a C++ doc:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Direction_2.html
 
 
Method resolution order:
Direction_2
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__ge__(...)
__gt__(...)
__init__(...)
d = Direction_2(Vector_2 v)
introduces the direction d of vector v.
d = Direction_2(Line_2 l)
introduces the direction d of line l.
d = Direction_2(Ray_2 r)
introduces the direction d of Ray_2 r.
d = Direction_2(Segment_2 s)
introduces the direction d of Segment_2 s.
d = Direction_2(x,y)
introduces a direction d passing through the origin and the point with Cartesian coordinates (x, y)
__le__(...)
__lt__(...)
__ne__(...)
__neg__(...)
counterclockwise_in_between(...)
d.counterclockwise_in_between(d1,d2) ->bool
returns true, iff d is not equal to d1, and while rotating counterclockwise starting at d1,
d is reached strictly before d2 is reached. Note that true is returned if d1 == d2,
unless also d == d1.
delta(...)
delta(self,i) -> returns values, such that d== Direction_2(delta(0),delta(1)).
Precondition: 0 <= i <= 1.
dx(...)
dx(self) -> returns delta(0).
dy(...)
dy(self) -> returns delta(1).
perpendicular(...)
transform(...)
transform(self,Aff_transformation_2 t) -> Direction_2
returns the direction obtained by applying t on d.
vector(...)
vector(self) -> Vector_2
returns a vector that has the same direction as d.

Data and other attributes defined here:
__instance_size__ = 24

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 Direction_3(Boost.Python.instance)
    An object of the class Direction_3 is a vector in the three-dimensional vector space
where we forget about their length. They can be viewed as unit vectors, 
although there is no normalization internally, since this is error prone. 
Directions are used whenever the length of a vector does not matter. 
They also characterize a set of parallel lines that have the same orientation or 
the direction normal to parallel planes that have the same orientation. 
For example, you can ask for the direction orthogonal to an oriented plane, or 
the direction of an oriented line.
For more details see a C++ doc:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Direction_3.html
 
 
Method resolution order:
Direction_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
d = Direction_3Vector_3 v)
introduces a direction d initialised with the direction of vector v.
 
d = Direction_3Line_3 l)
introduces the direction d of line l.
 
d = Direction_3Ray_3<Kernel> r)
introduces the direction d of ray r.
 
d = Direction_3Segment_3 s)
introduces the direction d of segment s.
 
d = Direction_3( x, y, z)
introduces a direction d initialised with the direction from the origin 
to the point with Cartesian coordinates (x, y, z).
__ne__(...)
__neg__(...)
delta(...)
delta(self,int i) ->double
returns values, such that d== Direction_3(delta(0),delta(1),delta(2)).
Precondition: : 0 <= i <= 2
dx(...)
d.dx(self) ->  returns delta(0).
dy(...)
d.dy(self) ->  returns delta(1).
dz(...)
d.dz(self) ->  returns delta(2).
transform(...)
d.transform(self,Aff_transformation_3 t) -> Direction_3
returns the direction obtained by applying t on d.
vector(...)
d.vector(self) -> Vector_3
returns a vector that has the same direction as d.

Data and other attributes defined here:
__instance_size__ = 32

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 Identity_transformation(Boost.Python.instance)
    Tag class for affine transformations.
 
 
Method resolution order:
Identity_transformation
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)

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 Iso_rectangle_2(Boost.Python.instance)
    An object s of the data type Iso_cuboid_3 is a rectangle in the Euclidean plane E x E
with sides parallel to the x and y axis of the coordinate system.
Although they are represented in a canonical form by only two vertices, 
namely the lower left and the upper right vertex, we provide functions for ``accessing'' 
the other vertices as well. The vertices are returned in counterclockwise order.
Iso-oriented rectangles and bounding boxes are quite similar. 
The difference however is that bounding boxes have always double coordinates, 
whereas the coordinate type of an iso-oriented rectangle is chosen by the user. 
For more details see a C++ documentation:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Iso_rectangle_2.html
 
 
Method resolution order:
Iso_rectangle_2
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
r = Iso_rectangle_2Point_2 p, Point_2 q)
introduces an iso-oriented rectangle r with diagonal opposite vertices p and q. 
Note that the object is brought in the canonical form.
 
r = Iso_rectangle_2Point_2 left,Point_2 right,Point_2 bottom,Point_2 top)
introduces an iso-oriented rectangle r whose minimal x coordinate is the one of left, the maximal x coordinate 
is the one of right, the minimal y coordinate is the one of bottom, the maximal y coordinate is the one of top
 
r = Iso_rectangle_2( min_hx,min_hy,min_hz,max_hx,max_hy,hw = 1)
introduces an iso-oriented rectangle r with diagonal opposite vertices (min_hx/hw, min_hy/hw) and (max_hx/hw, max_hy/hw).
Precondition: hw # 0.
__ne__(...)
area(...)
r.area(self) -> double
returns the area of r.
bbox(...)
r.bbox(self) -> Bbox
returns a bounding box containing r.
bounded_side(...)
r.bounded_side(self,Point_2 p) -> Bounded_side
returns either ON_UNBOUNDED_SIDE, ON_BOUNDED_SIDE, or the constant ON_BOUNDARY, depending on where point p is.
has_on_boundary(...)
r.has_on_boundary(self,Point_2 p) ->bool
has_on_bounded_side(...)
r.has_on_bounded_side(self,Point_2 p) ->bool
has_on_unbounded_side(...)
r.has_on_unbounded_side(self,Point_2 p) ->bool
is_degenerate(...)
r.is_degenerate(self) ->bool
c is degenerate, if all vertices are collinear.
max(...)
r.max(self) -> Point_2
returns the largest vertex of r (= vertex(7)).
max_coord(...)
r.max_coord(self) ->double
returns i-th Cartesian coordinate of the largest vertex of r.
Precondition: 0 <= i<= 2.
min(...)
r.min(self) -> Point_2
returns the smallest vertex of r (= vertex(0)).
min_coord(...)
r.min_coord(self,int i) ->double
returns i-th Cartesian coordinate of the smallest vertex of r.
Precondition: 0 <= i<= 2.
transform(...)
r.transform(self, Aff_transformation_3 t) -> Iso_cuboid_3
returns the iso-oriented rectangle obtained by applying t on the smallest and the largest of r.
Precondition: The angle at a rotation must be a multiple of pi/2, otherwise the resulting 
rectangle does not have the same size. Note that rotating about an arbitrary angle can even result
in a degenerate iso-oriented rectangle.
vertex(...)
r.vertex(self,int i) -> Point_2
returns the i'th vertex modulo 8 of r. starting with the lower left vertex.
xmax(...)
r.ymin(self) -> double
returns smallest Cartesian y-coordinate in r.
xmin(...)
r.xmin(self) -> double
returns smallest Cartesian x-coordinate in r.
ymax(...)
r.ymax(self) -> double
returns largest Cartesian y-coordinate in r.
ymin(...)
r.xmax(self) -> double
returns largest Cartesian x-coordinate in r.

Data and other attributes defined here:
__instance_size__ = 40

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 Line_2(Boost.Python.instance)
    An object l of the data type Line_2 is a directed straight line in the two-dimensional Euclidean plane ExE.
It is defined by the set of points with Cartesian  coordinates (x,y) that satisfy the equation l : ax + by + c = 0
The line splits ExE in a positive and a negative side.
A point p with Cartesian coordinates (px, py) is on the positive side of l, iff a px + b py + c > 0, it is on the negative side of l, iff a px + b py + c < 0. The positive side is to the left of l.
For more details see a C++ documentation:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Line_2.html
 
 
Method resolution order:
Line_2
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
l = Line_2( double a, double b, double c)
introduces a line l with the line equation in Cartesian coordinates ax +by +c = 0.
l = Line_2Point_2 p, Point_2 q)
introduces a line l passing through the points p and q. Line l is directed from p to q.
l = Line_2Point_2 p, Direction_2 d)
introduces a line l passing through point p with direction d.
l = Line_2Point_2 p, Vector_2 v)
introduces a line l passing through point p and oriented by v.
l = Line_2Segment_2 s)
introduces a line l supporting the segment s, oriented from source to target.
l = Line_2Ray_2 r)
introduces a line l supporting the ray r, with same orientation.
__ne__(...)
a(...)
a(self) -> returns the first coefficient of l.
b(...)
b(self) -> returns the second coefficient of l.
c(...)
c(self) -> returns the third coefficient of l.
direction(...)
direction(self) -> Line_2
returns the direction of l.
has_on(...)
has_on_boundary(...)
has_on_negative_side(...)
has_on_positive_side(...)
is_degenerate(...)
is_degenerate(slef) ->bool
line l is degenerate, if the coefficients a and b of the line equation are zero.
is_horizontal(...)
is_vertical(...)
opposite(...)
opposite(self) -> Line_2
returns the line with opposite direction.
oriented_side(...)
oriented_side(slef, Point_2 p) -> Oriented_side
returns ON_ORIENTED_BOUNDARY, ON_NEGATIVE_SIDE, or the constant ON_POSITIVE_SIDE, depending on the position of p relative to the oriented line l.
perpendicular(...)
perpendicular(self,Point_2 p) -> Line_2
returns the line perpendicular to l and passing through p,
where the direction is the direction of l rotated counterclockwise by 90 degrees.
point(...)
point(slef,i) -> Point_2
returns an arbitrary point on l.
It holds point(i) == point(j), iff i==j.
Furthermore, l is directed from point(i)  to point(j), for all i < j.
projection(...)
projection(self,Point_2 p) -> Point_2
returns the orthogonal projection of p onto l.
to_vector(...)
to_vector(self) -> Vector_2
returns a vector having the direction of l.
transform(...)
transform(slef,Aff_transformation_2 t) -> Line_2
returns the line obtained by applying t on a point on l and the direction of l.
x_at_y(...)
x_at_y(self,y) -> returns the x-coordinate of the point at l with given y-coordinate.
Precondition: l is not horizontal.
y_at_x(...)
y_at_x(self,x) -> returns the y-coordinate of the point at l with given x-coordinate.
Precondition: l is not vertical.

Data and other attributes defined here:
__instance_size__ = 32

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 Line_3(Boost.Python.instance)
    An object l of the data type Line_3 is a directed straight line in the three-dimensional Euclidean space
 
For more details see a C++ doc:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Line_3.html
 
 
Method resolution order:
Line_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
l = Line_3Point_3 p, Point_3 q)
introduces a line l passing through the points p and q. 
Line l is directed from p to q.
 
l = Line_3Point_3 p, Direction_3 d)
introduces a line l passing through point p with direction d.
 
l = Line_3Point_3 p, Vector_3 v)
introduces a line l passing through point p and oriented by v.
 
l = Line_3Segment_3 s)
returns the line supporting the segment s, oriented from source to target.
 
l = Line_3Ray_3 r)
returns the line supporting the ray r, with the same orientation.
__ne__(...)
direction(...)
l.direction(self) -> Direction_3
returns the direction of l.
has_on(...)
l.has_on(self,Point_3 p) -> bool
returns true iff p lies on l.
is_degenerate(...)
l.is_degenerate(self) -> bool
returns true iff line l is degenerated to a point.
opposite(...)
l.opposite(self) -> Line_3
returns the line with opposite direction.
perpendicular_plane(...)
l.perpendicular_plane(self, Point_3 p) -> Plane_3
returns the plane perpendicular to l passing through p.
point(...)
l.point(self,int i) -> Point_3
returns an arbitrary point on l. It holds point(i) = point(j), iff i=j.
projection(...)
l.projection(self,Point_3 p) -> Point_3
returns the orthogonal projection of p on l.
to_vector(...)
l.to_vector(self) -> Vector_3
returns a vector having the same direction as l.
transform(...)
l.transform(self,Aff_transformation_3 t) -> Line_3
returns the line obtained by applying t on a point on l and the direction of l.

Data and other attributes defined here:
__instance_size__ = 56

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 Null_vector(Boost.Python.instance)
    A symbolic constant used to construct zero length vectors.
 
 
Method resolution order:
Null_vector
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)

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 Origin(Boost.Python.instance)
    CGAL defines a symbolic constant ORIGIN which denotes the point at the origin.
Origin is the type of this constant. It is used in the conversion between points and vectors.
.
 
 
Method resolution order:
Origin
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)

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 Plane_3(Boost.Python.instance)
    An object h of the data type Plane_3 is an oriented plane in the three-dimensional Euclidean space.
It is defined by the set of points with Cartesian coordinates (x,y,z) that satisfy the plane equation:
h : a x + b y + c z + d = 0
The plane splits E3 in a positive and a negative side. 
A point p with Cartesian coordinates (px, py, pz) is on the positive side of h,
iff a px + b py +c pz + d > 0. It is on the negative side, iff a px + b py +c pz + d < 0.
For more details see a C++ doc at :
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Plane_3.html
 
 
Method resolution order:
Plane_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
h = Plane_3( a,b,c,d)
creates a plane h defined by the equation a px + b py + c pz + d = 0. 
Notice that h is degenerate if a = b = c.
 
h = Plane_3(    Point_3 p,Point_3 q,Point_3 r)
creates a plane h passing through the points p, q and r. 
The plane is oriented such that p, q and r are oriented in a positive sense 
(that is counterclockwise) when seen from the positive side of h. 
Notice that h is degenerate if the points are collinear.
 
h = Plane_3Point_3 p, Vector_3 v)
introduces a plane h that passes through point p and that is orthogonal to v.
 
h = Plane_3Point_3 p, Direction_3 d)
introduces a plane h that passes through point p and that has as an orthogonal direction equal to d.
 
h = Plane_3Line_3 l, Point_3 p)
introduces a plane h that is defined through the three points l.point(0), l.point(1) and p.
 
h = Plane_3Ray_3 r, Point_3 p)
introduces a plane h that is defined through the three points r.point(0), p.point(1) and p.
 
h = Plane_3Segment_3 s, Point_3 p)
introduces a plane h that is defined through the three points s.source(), s.target() and p.
__ne__(...)
a(...)
h.a(self) -> returns the first coefficient of h.
b(...)
h.b(self) -> returns the second coefficient of h
base1(...)
h.base1(self) -> Vector_3
returns a vector orthogonal to orthogonal_vector().
base2(...)
h.base2(self) -> Vector_3
returns a vector that is both orthogonal to base1(), and to orthogonal_vector(),
and such that the result of orientation( point(), point() + base1(), point()+base2(), point() + orthogonal_vector() ) is positive.
c(...)
h.c(self) -> returns the third coefficient of h
d(...)
h.d(self) -> returns the fourth coefficient of h
has_on(...)
h.has_on(self, Point_3 p) -> bool
 
h.has_on(self, Line_3 l) -> bool
has_on_negative_side(...)
h.has_on_negative_side(self,Point_3 p) -> bool
has_on_positive_side(...)
h.has_on_positive_side(self,Point_3 p) -> bool
is_degenerate(...)
h.is_degenerate(self) -> bool
Plane h is degenerate, if the coefficients a, b, and c of the plane equation are zero.
opposite(...)
h.opposite(self) -> Plane_3
returns the plane with opposite orientation.
oriented_side(...)
h.oriented_side(self) -> Oriented_side
returns either ON_ORIENTED_BOUNDARY, 
or the constant ON_POSITIVE_SIDE, or the constant ON_NEGATIVE_SIDE, 
determined by the position of p relative to the oriented plane h.
orthogonal_direction(...)
h.orthogonal_direction(self) -> Direction_3
returns the direction that is orthogonal to h and that is directed to the positive side of h.
orthogonal_vector(...)
h.orthogonal_vector(self) -> Vector_3
returns a vector that is orthogonal to h and that is directed to the positive side of h.
perpendicular_line(...)
h.perpendicular_line(self,Point_3 p) -> Line_3
returns the line that is perpendicular to h and that passes through point p.
The line is oriented from the negative to the positive side of h.
point(...)
h.point(self) -> Point_3
returns an arbitrary point on h.
projection(...)
h.projection(self,Point_3 p) -> Point_3
returns the orthogonal projection of p on h.
to_2d(...)
h.to_2d(self,Point_3 p) -> Point_2
returns the image point of the projection of p under an affine transformation, which maps h onto the xy-plane, with the z-coordinate removed.
to_3d(...)
h.to_3d(self,Point_2 p) -> Point_3
returns a point q, such that to_2dto_3d( p ))  is equal to p.
transform(...)
h.transform(self,Aff_transformation_3 t) -> Plane_3
returns the plane obtained by applying t on a point of h and the orthogonal direction of h.

Data and other attributes defined here:
__instance_size__ = 40

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_2(Boost.Python.instance)
    An object of the class Point_2 is a point in the two-dimensional Euclidean plane ExE.
 
 
Method resolution order:
Point_2
Boost.Python.instance
__builtin__.object

Methods defined here:
__add__(...)
__eq__(...)
__ge__(...)
__getitem__(...)
p[i] -> returns cartesian(i).Precondition: 0 <= i <= 1.
__gt__(...)
__init__(...)
__le__(...)
__lt__(...)
__ne__(...)
__sub__(...)
bbox(...)
bbox(self) -> returns a bounding box containing p.
Note that bounding boxes are not parameterized with whatsoever.
cartesian(...)
cartesian(self,i) -> returns the i'th Cartesian  coordinate of p, starting with 0.
Precondition: 0 <= i <= 1.
dimension(...)
dimension(slef) -> returns the dimension (the constant 2).
homogeneous(...)
homogeneous(self,i) -> returns the i'th homogeneous coordinate of p, starting with 0.Precondition: 0 <= i <= 2.
hw(...)
hw(self) -> returns the homogenizing coordinate.
hx(...)
hx(self) -> returns the homogeneous x coordinate.
hy(...)
hy(self) -> returns the homogeneous y coordinate.
transform(...)
transform(self,Aff_transformation_2 t) -> returns the point obtained by applying t on p.
x(...)
x(self) -> returns the Cartesian  x coordinate, that is hx/hw.
y(...)
y(self) -> returns the Cartesian  y coordinate, that is hy/hw.

Data and other attributes defined here:
__instance_size__ = 24

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_3(Boost.Python.instance)
    An object of the class Point_3 is a point in the three-dimensional Euclidean space
 
 
Method resolution order:
Point_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__add__(...)
__eq__(...)
__ge__(...)
__getitem__(...)
p[i] -> returns cartesian(i).Precondition: 0 <= i <= 2.
__gt__(...)
__init__(...)
p = Point_3(ORIGIN)
introduces a point with Cartesian coordinates(0,0,0).
 
p = Point_3(hx,hy,hz,hw = 1)
introduces a point p initialized to (hx/hw,hy/hw, hz/hw).
Precondition: hw #0.
__le__(...)
__lt__(...)
__ne__(...)
__sub__(...)
bbox(...)
bbox(self) -> returns a bounding box containing p.
Note that bounding boxes are not parameterized with whatsoever.
cartesian(...)
cartesian(self,i) -> returns the i'th Cartesian  coordinate of p, starting with 0.
Precondition: 0 <= i <= 2.
dimension(...)
dimension(slef) -> returns the dimension (the constant 3).
homogeneous(...)
homogeneous(self,i) -> returns the i'th homogeneous coordinate of p, starting with 0.Precondition: 0 <= i <= 2.
hw(...)
hw(self) -> returns the homogenizing coordinate.
hx(...)
hx(self) -> returns the homogeneous x coordinate.
hy(...)
hy(self) -> returns the homogeneous y coordinate.
hz(...)
hz(self) -> returns the homogeneous z coordinate.
transform(...)
transform(self,Aff_transformation_2<Kernel> t) -> returns the point obtained by applying t on p.
x(...)
x(self) -> returns the Cartesian  x coordinate, that is hx/hw.
y(...)
y(self) -> returns the Cartesian  y coordinate, that is hy/hw.
z(...)
z(self) -> returns the Cartesian  z coordinate, that is hz/hw.

Data and other attributes defined here:
__instance_size__ = 32

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 Ray_2(Boost.Python.instance)
    An object r of the data type Ray_2 is a directed straight ray in the two-dimensional Euclidean plane ExE. It starts in a point called the source of r and goes to infinity.
for more details see a C++ doc:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Ray_2.html
 
 
Method resolution order:
Ray_2
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
r = Ray_2(self,Point_2 p,Point_2 q)
introduces a ray with source p and passing through point q.
r = Ray_2(self,Point_2 p,Direction_2 d)
introduces a ray starting at source p with direction d.
r = Ray_2(self,Point_2 p,Vector_2 v)
introduces a ray r starting at source p with the direction of v.
r = Ray_2(self,Point_2 p,line_2 l)
introduces a ray r starting at source p with the same direction as l.
__ne__(...)
collinear_has_on(...)
collinear_has_on(self,Point_2 p) -> bool
checks if point p is on r.
This function is faster than function has_on() if the precondition checking is disabled.
Precondition: p is on the supporting line of r.
direction(...)
direction(self) -> Direction_2
returns the direction of r.
has_on(...)
has_on(self,Point_2 p) -> bool
A point is on r, iff it is equal to the source of r, or if it is in the interior of r
is_degenerate(...)
is_degenerate(self) -> bool
ray r is degenerate, if the source and the second defining point fall together (that is if the direction is degenerate).
is_horizontal(...)
is_vertical(...)
opposite(...)
opposite(self) -> Ray_2
returns the ray with the same source and the opposite direction.
point(...)
point(self,i) -> Point_2
returns a point on r. point(0) is the source, point(i), with i>0, is different from the source.
Precondition: i 0.
second_point(...)
source(...)
source(self) -> Point_2
returns the source of r
start(...)
supporting_line(...)
supporting_line(self) -> line_2
returns the line supporting r which has the same direction.
to_vector(...)
to_vector(self) -> Vector_2
returns a vector giving the direction of r
transform(...)
transform(Aff_transformation_2 t) -> Ray_2
returns the ray obtained by applying t on the source and on the direction of r.

Data and other attributes defined here:
__instance_size__ = 40

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 Ray_3(Boost.Python.instance)
    An object r of the data type Ray_3 is a directed straight ray in the three-dimensional Euclidean space. It starts in a point called the source of r and goes to infinity.
for more details go to: http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Ray_3.html
 
 
Method resolution order:
Ray_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
r = Ray_3(Point_3 p,Point_3 q)
introduces a ray with source p and passing through point q.
r = Ray_3(Point_3 p,Direction_3 d)
introduces a ray starting at source p with direction d.
r = Ray_3(Point_3 p,Vector_3 v)
introduces a ray r starting at source p with the direction of v.
r = Ray_3(Point_3 p,line_3 l)
introduces a ray r starting at source p with the same direction as l.
__ne__(...)
collinear_has_on(...)
collinear_has_on(self,Point_3 p) -> bool
checks if point p is on r.
This function is faster than function has_on() if the precondition checking is disabled.
Precondition: p is on the supporting line of r.
direction(...)
direction(self) -> Direction_3
returns the direction of r.
has_on(...)
has_on(self,Point_3 p) -> bool
A point is on r, iff it is equal to the source of r, or if it is in the interior of r
is_degenerate(...)
is_degenerate(self) -> bool
ray r is degenerate, if the source and the second defining point fall together (that is if the direction is degenerate).
opposite(...)
opposite(self) -> Ray_3
returns the ray with the same source and the opposite direction.
point(...)
point(self,i) -> Point_3
returns a point on r. point(0) is the source, point(i), with i>0, is different from the source.
Precondition: i>=0.
second_point(...)
source(...)
source(self) -> Point_3
returns the source of r
start(...)
supporting_line(...)
supporting_line(self) -> line_2
returns the line supporting r which has the same direction.
to_vector(...)
to_vector(self) -> Vector_3
returns a vector giving the direction of r
transform(...)
transform(Aff_transformation_2 t) -> Ray_3
returns the ray obtained by applying t on the source and on the direction of r.

Data and other attributes defined here:
__instance_size__ = 56

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 Reflection(Boost.Python.instance)
    Tag class for affine transformations.
 
 
Method resolution order:
Reflection
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)

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 Rotation(Boost.Python.instance)
    Tag class for affine transformations.
 
 
Method resolution order:
Rotation
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)

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 Scaling(Boost.Python.instance)
    Tag class for affine transformations.
 
 
Method resolution order:
Scaling
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)

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 Segment_2(Boost.Python.instance)
    An object s of the data type Segment_2 is a directed straight line segment in the two-dimensional Euclidean plane RxR,
 i.e. a straight line segment [p,q] connecting two points p,q in RxR.
The segment is topologically closed, i.e. the end points belong to it.
Point p is called the source and q is called the target of s. 
The length of s is the Euclidean distance between p and q. Note that there is only a function to compute the square of the length,
because otherwise we had to perform a square root operation which is not defined for all number types, which is expensive, and may not be exact..
For more details see a C++ doc:
http://www.cgal.org/Manual/doc_html/cgal_manual/Kernel_23_ref/Class_Segment_2.html
 
Creation:
 s = Segment_2Point_2 p, Point_2 q)
introduces a segment s with source p and target q.
 The segment is directed from the source towards the target.
 
 
Method resolution order:
Segment_2
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__getitem__(...)
s[i] -> Point_2
returns vertex(i)
__init__(...)
__ne__(...)
bbox(...)
bbox(slef) -> Bbox_2
returns a bounding box containing s.
collinear_has_on(...)
collinear_has_on(slef,Point_2) -> bool
checks if point p is on segment s. This function is faster than function has_on().
Precondition: p is on the supporting line of s.
direction(...)
direction(slef) -> Direction_2
returns the direction from source to target of s.
end(...)
has_on(...)
has_on(slef,Point_2 p) -> bool
A point p is on s, iff it is equal to the source or target of s, or if it is in the interior of s.
is_degenerate(...)
is_degenerate(slef) -> bool
segment s is degenerate, if source and target are equal.
is_horizontal(...)
is_vertical(...)
max(...)
max(slef) ->  Point_2
returns the point of Segment with lexicographically largest coordinate.
min(...)
min(slef) ->  Point_2
returns the point of s with lexicographically smallest coordinate.
opposite(...)
opposite(slef) -> Segment_2
returns a segment with source and target point interchanged.
point(...)
point(slef) -> returns vertex(i).
source(...)
source(slef) -> Point_2
returns the source of s.
squared_length(...)
squared_length(slef) -> double
returns the squared length of s.
start(...)
supporting_line(...)
supporting_line(self) -> Line_2
returns the line l passing through s.
Line l has the same orientation as segment s.
target(...)
target(self) -> Point_2
returns the target of s.
to_vector(...)
to_vector(slef) -> Vector_2
returns the vector s.target() - s.source().
transform(...)
transform(slef,Aff_transformation_2 t) -> Segment_2
returns the segment obtained by applying t on the source and the target of s.
vertex(...)
vertex(slef,i) -> Point_2
returns source or target of s: vertex(0) returns the source of s, vertex(1) returns the target of s.
The parameter i is taken modulo 2, which gives easy access to the other vertex.

Data and other attributes defined here:
__instance_size__ = 40

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 Segment_3(Boost.Python.instance)
    An object s of the data type Segment_3 is a directed straight line segment in the three-dimensional Euclidean space
i.e. a straight line segment [p,q] connecting two points p,q The segment is topologically closed, i.e.
the end points belong to it. Point p is called the source and q is called the target of s. 
The length of s is the Euclidean distance between p and q.
Note that there is only a function to compute the square of the length, because otherwise we had to perform a square 
root operation which is not defined for all number types, which is expensive, and may not be exact.
For more details see a C++ doc:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Segment_3.html
 
 
Method resolution order:
Segment_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__getitem__(...)
s[i] -> Point_3
returns vertex(i)
__init__(...)
s = Segment_3Point_3 p, Point_3 q)
introduces a segment s with source p and target q.
 The segment is directed from the source towards the target.
__ne__(...)
bbox(...)
bbox(slef) -> Bbox_3
returns a bounding box containing s.
collinear_has_on(...)
collinear_has_on(slef,Point_3) -> bool
checks if point p is on segment s. This function is faster than function has_on().
Precondition: p is on the supporting line of s.
direction(...)
direction(slef) -> Direction_3
returns the direction from source to target of s.
has_on(...)
has_on(slef,Point_3 p) -> bool
A point p is on s, iff it is equal to the source or target of s, or if it is in the interior of s.
is_degenerate(...)
is_degenerate(slef) -> bool
segment s is degenerate, if source and target are equal.
max(...)
max(slef) ->  Point_3
returns the point of Segment with lexicographically largest coordinate.
min(...)
min(slef) ->  Point_3
returns the point of s with lexicographically smallest coordinate.
opposite(...)
opposite(slef) -> Segment_3
returns a segment with source and target point interchanged.
point(...)
point(slef,int i) -> returns vertex(i).
source(...)
source(slef) -> Point_3
returns the source of s.
squared_length(...)
squared_length(slef) -> double
returns the squared length of s.
supporting_line(...)
supporting_line(self) -> Line_3
returns the line l passing through s.
Line l has the same orientation as segment s.
target(...)
target(self) -> Point_3
returns the target of s.
to_vector(...)
to_vector(slef) -> Vector_3
returns the vector s.target() - s.source().
transform(...)
transform(slef,Aff_transformation_3 t) -> Segment_3
returns the segment obtained by applying t on the source and the target of s.
vertex(...)
vertex(slef,i) -> Point_3
returns source or target of s: vertex(0) returns the source of s, vertex(1) returns the target of s.
The parameter i is taken modulo 2, which gives easy access to the other vertex.

Data and other attributes defined here:
__instance_size__ = 56

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 Sphere_3(Boost.Python.instance)
    An object of type Sphere_3 is a sphere in the three-dimensional Euclidean space.
The sphere is oriented, i.e. its boundary has clockwise or counterclockwise orientation. 
The boundary splits  E3 into a positive and a negative side, where the positive side is to the left of the boundary. 
The boundary also splits  E3 into a bounded and an unbounded side. 
Note that the sphere can be degenerated, i.e. the squared radius may be zero.
For more details see a C++ doc:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Sphere_3.html
 
 
Method resolution order:
Sphere_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
c = Sphere_3Point_3 center,squared_radius,Orientation ori = COUNTERCLOCKWISE)introduces a variable c of type Sphere_3
It is initialized to the sphere with center center, squared radius squared_radius and orientation ori.
Precondition: ori # COPLANAR,, and further, squared_radius >= 0.
 
c = Sphere_3Point_3 p,Point_3 q,Point_3 r,Point_3 s);
introduces a variable c of type Sphere_3
It is initialized to the unique sphere which passes through the points p, q,r and s. 
The orientation of the sphere is the orientation of the point quadruple p, q, r,s.
Precondition: p, q, r and s are not collinear.
 
c = Sphere_3Point_3 p,Point_3 q,Point_3 r, Orientation ori = COUNTERCLOCKWISE)
 
introduces a variable c of type Sphere_3. It is initialized to the smallest sphere which passes through the points p,q and r.
Precondition: ori # COPLANAR.
c = Sphere_3Point_3 p,Point_3 q,Orientation ori = COUNTERCLOCKWISE)
introduces a variable c of type Sphere_3
It is initialized to the smallest sphere which passes through p and q
Precondition: ori # COPLANAR.
 
c = Sphere_3Point_3 center,Orientation ori = COUNTERCLOCKWISE)
introduces a variable c of type Sphere_3
It is initialized to the sphere with center center, squared radius zero and orientation ori.
Precondition: ori # COPLANAR.
Postcondition: c.is_degenerate() = true.
__ne__(...)
bbox(...)
c.bbox(self) -> Bbox_3
returns a bounding box containing c.
bounded_side(...)
c.bounded_side(self, Point_3 p) -> Bounded_side
returns ON_BOUNDED_SIDE, ON_BOUNDARY, 
or ON_UNBOUNDED_SIDE  iff p lies properly inside, on the boundary, or properly outside of c, resp.
center(...)
c.center(self) ->Point_3
returns the center of c.
has_on_boundary(...)
c.has_on_boundary(self , Point_3 p) -> bool
has_on_bounded_side(...)
c.has_on_bounded_side(self , Point_3 p) -> bool
has_on_negative_side(...)
c.has_on_negative_side(self , Point_3 p) -> bool
has_on_positive_side(...)
c.has_on_positive_side(self , Point_3 p) -> bool
has_on_unbounded_side(...)
c.has_on_unbounded_side(self , Point_3 p) -> bool
is_degenerate(...)
c.is_degenerate(self) -> bool
returns true, iff c is degenerate, i.e. if c has squared radius zero.
opposite(...)
c.opposite(self) -> Sphere_3
returns the sphere with the same center and squared radius as c but with opposite orientation .
orientation(...)
c.orientation(self) -> Orientation
returns the orientation of c.
oriented_side(...)
c.oriented_side(self ,Point_3 p) ->Oriented_side
returns either the constant ON_ORIENTED_BOUNDARY, ON_POSITIVE_SIDE, 
or ON_NEGATIVE_SIDE, iff p lies on the boundary, properly on 
the positive side, or properly on the negative side of c, resp.
squared_radius(...)
c.squared_radius(self) ->double
returns the squared radius of c.

Data and other attributes defined here:
__instance_size__ = 44

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 Tetrahedron_3(Boost.Python.instance)
    An object t of the class Tetrahedron_3 is an oriented tetrahedron in the three-dimensional Euclidean space.
It is defined by four vertices p0, p1, p2 and p3. The orientation of a tetrahedron is the orientation of its four vertices.
That means it is positive when p3 is on the positive side of the plane defined by p0, p1 and p2.
The tetrahedron itself splits the space 3 in a positive and a negative side.
The boundary of a tetrahedron splits the space in two open regions, a bounded one and an unbounded one.
 
For more details see a C++ documentation:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Tetrahedron_3.html
 
 
Method resolution order:
Tetrahedron_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
t = Tetrahedron_3Point_3 p0, Point_3 p1,Point_3 p2, Point_3 p3)
introduces a tetrahedron t with vertices p0, p1, p2 and p3.
__ne__(...)
bbox(...)
t.bbox(self) -> Bbox_3
returns a bounding box containing t.
bounded_side(...)
t.bounded_side(self,Point_3 p) -> Bounded_side
Precondition: : t is not degenerate.
has_on_boundary(...)
t.has_on_boundary(self,Point_3 p) ->bool
has_on_bounded_side(...)
t.has_on_bounded_side(self,Point_3 p) ->bool
has_on_negative_side(...)
c.has_on_negative_side(self , Point_3 p) -> bool
has_on_positive_side(...)
c.has_on_positive_side(self , Point_3 p) -> bool
has_on_unbounded_side(...)
t.has_on_unbounded_side(self,Point_3 p) ->bool
is_degenerate(...)
t.is_degenerate(self) ->bool
Tetrahedron t is degenerate, if the vertices are coplanar.
orientation(...)
t.orientation(self) -> Orientation
returns the orientation of t.
oriented_side(...)
t.oriented_side (self,Point_3 p) -> Oriented_side
Precondition: : t is not degenerate.
transform(...)
t.transform(self, Aff_transformation_3 t) -> Tetrahedron_3
returns the tetrahedron obtained by applying at on the three vertices of t.
vertex(...)
t.vertex(self,int i) -> Point_3
returns the i'th vertex modulo 4 of t.
volume(...)
t.volume(self) -> double
returns the volume of t.

Data and other attributes defined here:
__instance_size__ = 104

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 Translation(Boost.Python.instance)
    Tag class for affine transformations.
 
 
Method resolution order:
Translation
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)

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 Triangle_2(Boost.Python.instance)
    An object t of the class Triangle_2 is a triangle in the two-dimensional Euclidean plane.
Triangle t is oriented, i.e., its boundary has clockwise or counterclockwise orientation. 
We call the side to the left of the boundary the positive side and the side to the right of the boundary the negative side.
The boundary of a triangle splits the plane in two open regions, a bounded one and an unbounded one. 
 
For more details see a C++ doc:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Triangle_2.html
 
 
Method resolution order:
Triangle_2
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
t.Triangle_2Point_2 p,Point_2 q,Point_2 r) -> introduces a triangle t with vertices p, q and r.
__ne__(...)
area(...)
t.area() -> double
returns the signed area of t.
bbox(...)
t.bbox( ) -> Bbox_2
returns a bounding box containing t.
bounded_side(...)
t.bounded_sidePoint_2 p) -> Bounded_side
returns the constant ON_BOUNDARY, ON_BOUNDED_SIDE, or else ON_UNBOUNDED_SIDE,
depending on where point p is.
Precondition: t is not degenerate.
has_on_boundary(...)
t.has_on_boundaryPoint_2 p) -> bool
has_on_bounded_side(...)
t.has_on_bounded_sidePoint_2 p) -> bool
has_on_negative_side(...)
t.has_on_negative_sidePoint_2 p) -> bool
has_on_positive_side(...)
t.has_on_positive_sidePoint_2 p) -> bool
has_on_unbounded_side(...)
t.has_on_unbounded_sidePoint_2 p) -> bool
is_degenerate(...)
t.is_degeneratePoint_2 p) -> bool
triangle t is degenerate, if the vertices are collinear.
opposite(...)
t.opposite( ) -> Triangle_2
returns a triangle where the boundary is oriented the other way round
(this flips the positive and the negative side, but not the bounded and unbounded side).
orientation(...)
t.orientation() -> Orientation
returns the orientation of t.
oriented_side(...)
t.oriented_sidePoint_2 p) -> Oriented_side
 
returns ON_ORIENTED_BOUNDARY, or POSITIVE_SIDE, or the constant ON_NEGATIVE_SIDE,
determined by the position of point p.
Precondition: t is not degenerate.
transform(...)
t.transform(  Aff_transformation_2 at) -> Triangle_2
returns the triangle obtained by applying at on the three vertices of t.
vertex(...)
t.vertex( int i) ->  Point_2
returns the i'th vertex modulo 3 of t.

Data and other attributes defined here:
__instance_size__ = 56

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 Triangle_3(Boost.Python.instance)
    An object t of the class Triangle_3 is a triangle in the three-dimensional Euclidean space. 
As the triangle is not a full-dimensional object there is 
only a test whether a point lies on the triangle or not.
For more details see a C++ documentation:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Triangle_3.html
 
 
Method resolution order:
Triangle_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
__init__(...)
t = Triangle_3Point_3 p, Point_3 q , Point_3 r)
introduces a triangle t with vertices p, q and r.
__ne__(...)
bbox(...)
t.bbox () -> Bbox_3
returns a bounding box containing t.
has_on(...)
v.has_on ( Point_3) -> bool
A point is on t, if it is on a vertex, an edge or the face of t.
is_degenerate(...)
t.is_degenerate () -> bool
t is degenerate if its vertices are collinear.
squared_area(...)
v.squared_area () -> returns a square of the area of t.
supporting_plane(...)
t.supporting_plane () -> Plane_3
returns the supporting plane of t, with same orientation.
transform(...)
t.transform (Aff_transformation_3 t) -> Triangle_3
returns the triangle obtained by applying at on the three vertices of t
vertex(...)
t.vertex ( int i) -> Point_3
returns the i'th vertex modulo 3 of t.

Data and other attributes defined here:
__instance_size__ = 80

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 Vector_2(Boost.Python.instance)
    An object of the class Vector_2 is a vector in the two-dimensional vector space ExE.
Geometrically spoken, a vector is the difference of two points p2, p1 and denotes the direction and the distance from p1 to p2.
 
CGAL defines a symbolic constant NULL_VECTOR.
We will explicitly state where you can pass this constant as an argument instead of a vector initialized with zeros. .
 
 
Method resolution order:
Vector_2
Boost.Python.instance
__builtin__.object

Methods defined here:
__add__(...)
__div__(...)
__eq__(...)
__getitem__(...)
v[i] -> returns cartesian(i).Precondition: 0 <= i <= 1.
__init__(...)
__mul__(...)
__ne__(...)
__neg__(...)
__radd__(...)
__rmul__(...)
__sub__(...)
cartesian(...)
cartesian(self,i) -> returns the i'th Cartesian  coordinate of v, starting with 0.
Precondition: 0 <= i <= 1.
dimension(...)
dimension(slef) -> returns the dimension (the constant 2).
direction(...)
direction(self) ->  returns the direction which passes through v.
Note that bounding boxes are not parameterized with whatsoever.
homogeneous(...)
homogeneous(self,i) -> returns the i'th homogeneous coordinate of v,starting with 0.Precondition: 0 <= i <= 2.
hw(...)
hw(self) -> returns the homogenizing coordinate.
hx(...)
hx(self) -> returns the homogeneous x coordinate.
hy(...)
hy(self) -> returns the homogeneous y coordinate.
perpendicular(...)
perpendicular(self,Orientation o) -> returns the vector perpendicular to v in clockwise or counterclockwise orientation.
squared_length(...)
transform(...)
transform(self,Aff_transformation_2<Kernel> t) -> returns the point obtained by applying t on v.
x(...)
x(self) -> returns the Cartesian  x coordinate, that is hx/hw.
y(...)
y(self) -> returns the Cartesian  y coordinate, that is hy/hw.

Data and other attributes defined here:
__instance_size__ = 24

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 Vector_3(Boost.Python.instance)
    An object of the class Vector_3 is a vector in the three-dimensional
vector space E x E x E.Geometrically spoken a vector is the difference of two points
p2, p1 and denotes the direction and the distance from p1 to p2.
CGAL defines a symbolic constant NULL_VECTOR. We will explicitly state where you
can pass this constant as an argument instead of a vector initialized with zeros. 
For more details see a C++ documentation:
http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Kernel_23_ref/Class_Vector_3.html
 
 
Method resolution order:
Vector_3
Boost.Python.instance
__builtin__.object

Methods defined here:
__add__(...)
__div__(...)
__eq__(...)
__getitem__(...)
__init__(...)
v = Vector_3Point_3 a, Point_3 b)
introduces the vector b-a.
 
v = Vector_3Segment_3 s)
introduces the vector s.target()-s.source().
 
v = Vector_3Ray_3 r)
introduces a vector having the same direction as r.
 
v = Vector_3Line_3 l)
introduces a vector having the same direction as l.
 
v = Vector_3( NULL_VECTOR);
introduces a null vector v.
 
v = Vector_3( hx,hy,hz,hw = 1)
introduces a vector v initialized to (hx/hw, hy/hw, hz/hw).
__mul__(...)
__ne__(...)
__neg__(...)
__radd__(...)
__rmul__(...)
__sub__(...)
cartesian(...)
v.cartesian( self int i) -> returns the i'th Cartesian coordinate of v, starting at 0.
Precondition: 0 <= i <= 2.
dimension(...)
v.dimension( self) -> returns the dimension( selfthe constant 3).
direction(...)
v.direction( self) -> returns the direction of v.
homogeneous(...)
v.homogeneous( self, int i) -> returns the i'th homogeneous coordinate of v, starting with 0.
Precondition: 0 <= i <= 3.
hw(...)
v.hw( self) -> returns the homogenizing coordinate.
hx(...)
v.hx( self) -> returns the homogeneous x coordinate.
hy(...)
v.hy( self) -> returns the homogeneous y coordinate.
hz(...)
v.hz( self) -> returns the homogeneous z coordinate.
squared_length(...)
v.squared_length( self) -> returns the squared_length of v.
transform(...)
v.transform( self , Aff_transformation_3 t) -> Vector_3
returns the vector obtained by applying t on v.v[i] -> returns the i'th Cartesian coordinate of v, starting at 0.
x(...)
v.x( self) ->  returns the x-coordinate of v, that is hx/hw.
y(...)
v.y( self) -> returns the y-coordinate of v, that is hy/hw.
z(...)
v.z( self) -> returns the z coordinate of v, that is hz/hw.

Data and other attributes defined here:
__instance_size__ = 32

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>

 
Data
        CLOCKWISE = CGAL.Kernel.Sign.NEGATIVE
COLLINEAR = CGAL.Kernel.Sign.ZERO
COPLANAR = CGAL.Kernel.Sign.ZERO
COUNTERCLOCKWISE = CGAL.Kernel.Sign.POSITIVE
DEGENERATE = CGAL.Kernel.Sign.ZERO
IDENTITY = <CGAL.Kernel.Identity_transformation object>
LEFT_TURN = CGAL.Kernel.Sign.POSITIVE
NULL_VECTOR = <CGAL.Kernel.Null_vector object>
ORIGIN = <CGAL.Kernel.Origin object>
REFLECTION = <CGAL.Kernel.Reflection object>
RIGHT_TURN = CGAL.Kernel.Sign.NEGATIVE
ROTATION = <CGAL.Kernel.Rotation object>
SCALING = <CGAL.Kernel.Scaling object>
TRANSLATION = <CGAL.Kernel.Translation object>