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_2( Identity_transformation) introduces an identity transformation.   t = Aff_transformation_2( Translation, Vector_2 v) introduces a translation by a vector v.   t = Aff_transformation_2( Rotation,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_2( Rotation,sine_rho,cosine_rho,hw = 1) introduces a rotation by the angle rho. Precondition: sine_rho**2 + cosine_rho**2 == hw2.   t = Aff_transformation_2( Scaling,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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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_2( Identity_transformation) introduces an identity transformation.   t = Aff_transformation_2( Translation, Vector_3 v) introduces a translation by a vector v.   t = Aff_transformation_2( Scaling,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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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_2( Point_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_2( Point_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_2( Point_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_2( Point_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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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_3( Vector_3 v) introduces a direction d initialised with the direction of vector v.   d = Direction_3( Line_3 l) introduces the direction d of line l.   d = Direction_3( Ray_3 r) introduces the direction d of ray r.   d = Direction_3( Segment_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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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_2( Point_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_2( Point_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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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_2( Point_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_2( Point_2 p, Direction_2 d) introduces a line l passing through point p with direction d. l = Line_2( Point_2 p, Vector_2 v) introduces a line l passing through point p and oriented by v. l = Line_2( Segment_2 s) introduces a line l supporting the segment s, oriented from source to target. l = Line_2( Ray_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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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_3( Point_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_3( Point_3 p, Direction_3 d) introduces a line l passing through point p with direction d.   l = Line_3( Point_3 p, Vector_3 v) introduces a line l passing through point p and oriented by v.   l = Line_3( Segment_3 s) returns the line supporting the segment s, oriented from source to target.   l = Line_3( Ray_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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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_3( Point_3 p, Vector_3 v) introduces a plane h that passes through point p and that is orthogonal to v.   h = Plane_3( Point_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_3( Line_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_3( Ray_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_3( Segment_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_2d( to_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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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 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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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_2( Point_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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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_3( Point_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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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_3( Point_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_3( Point_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_3( Point_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_3( Point_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_3( Point_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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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_3( Point_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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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_2( Point_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_side( Point_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_boundary( Point_2 p) -> bool has_on_bounded_side(...)t.has_on_bounded_side( Point_2 p) -> bool has_on_negative_side(...)t.has_on_negative_side( Point_2 p) -> bool has_on_positive_side(...)t.has_on_positive_side( Point_2 p) -> bool has_on_unbounded_side(...)t.has_on_unbounded_side( Point_2 p) -> bool is_degenerate(...)t.is_degenerate( Point_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_side( Point_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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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_3( Point_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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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 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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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_3( Point_3 a, Point_3 b) introduces the vector b-a.   v = Vector_3( Segment_3 s) introduces the vector s.target()-s.source().   v = Vector_3( Ray_3 r) introduces a vector having the same direction as r.   v = Vector_3( Line_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__ = __new__ = T.__new__(S, ...) -> a new object with type S, a subtype of T __weakref__ =

 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 = LEFT_TURN = CGAL.Kernel.Sign.POSITIVE NULL_VECTOR = ORIGIN = REFLECTION = RIGHT_TURN = CGAL.Kernel.Sign.NEGATIVE ROTATION = SCALING = TRANSLATION =