|
3.
Remember that Kernel::RT and Kernel::FT denote a RingNumberType and a FieldNumberType, respectively. For the kernel model Cartesian<T>, the two types are the same. For the kernel model Homogeneous<T>, Kernel::RT is equal to T, and Kernel::FT is equal to Quotient<T>.
| Point_3<Kernel>::Cartesian_const_iterator | |
|
An iterator for enumerating the
Cartesian
coordinates of a point.
| |
| Point_3<Kernel> p ( Origin ORIGIN); | |||
|
introduces a point with Cartesian coordinates(0,0,0).
| |||
| Point_3<Kernel> p ( int x, int y, int z); | |||
|
introduces a point p initialized to (x,y,z).
| |||
| Point_3<Kernel> p ( double x, double y, double z); | |||
|
introduces a point p initialized to (x,y,z)
provided RT supports it.
| |||
| Point_3<Kernel> p ( Kernel::RT hx, Kernel::RT hy, Kernel::RT hz, Kernel::RT hw = RT(1)); | |||
introduces a point p initialized to (hx/hw,hy/hw, hz/hw).
| |||
| Point_3<Kernel> p ( Kernel::FT x, Kernel::FT y, Kernel::FT z); | |||
|
introduces a point p initialized to (x,y,z).
| |||
| bool | p.operator== ( q) const | Test for equality: Two points are equal, iff their x, y and z coordinates are equal. |
| bool | p.operator!= ( q) const | Test for inequality. |
There are two sets of coordinate access functions, namely to the homogeneous and to the Cartesian coordinates. They can be used independently from the chosen kernel model.
| Kernel::RT | p.hx () const | returns the homogeneous x coordinate. |
| Kernel::RT | p.hy () const | returns the homogeneous y coordinate. |
| Kernel::RT | p.hz () const | returns the homogeneous z coordinate. |
| Kernel::RT | p.hw () const | returns the homogenizing coordinate. |
Note that you do not loose information with the homogeneous representation, because the FieldNumberType is a quotient.
| Kernel::FT | p.x () const | returns the Cartesian x coordinate, that is hx/hw. |
| Kernel::FT | p.y () const | returns the Cartesian y coordinate, that is hy/hw. |
| Kernel::FT | p.z () const | returns the Cartesian z coordinate, that is hz/hw. |
The following operations are for convenience and for compatibility with code for higher dimensional points. Again they come in a Cartesian and in a homogeneous flavor.
| Kernel::RT | p.homogeneous ( int i) const |
returns the i'th homogeneous coordinate of p, starting with 0.
| ||
| Kernel::FT | p.cartesian ( int i) const |
returns the i'th Cartesian coordinate of p, starting with 0.
| ||
| Kernel::FT | p.operator[] ( int i) const |
returns cartesian(i).
| ||
| Cartesian_const_iterator | p.cartesian_begin () const | returns an iterator to the Cartesian coordinates of p, starting with the 0th coordinate. | ||
| Cartesian_const_iterator | p.cartesian_end () const | returns an off the end iterator to the Cartesian coordinates of p. | ||
| int | p.dimension () const | returns the dimension (the constant 3). | ||
| Bbox_3 | p.bbox () const | returns a bounding box containing p. | ||
| Point_3<Kernel> | p.transform ( Aff_transformation_3<Kernel> t) const | |||
| returns the point obtained by applying t on p. | ||||
The following operations can be applied on points:
| bool | operator< ( p, q) | returns true iff p is lexicographically smaller than q (the lexicographical order being defined on the Cartesian coordinates). |
| bool | operator> ( p, q) | returns true iff p is lexicographically greater than q. |
| bool | operator<= ( p, q) | returns true iff p is lexicographically smaller or equal to q. |
| bool | operator>= ( p, q) | returns true iff p is lexicographically greater or equal to q. |
| Vector_3<Kernel> | operator- ( p, q) | returns the difference vector between q and p. You can substitute ORIGIN for either p or q, but not for both. |
| Point_3<Kernel> | operator+ ( p, Vector_3<Kernel> v) | |
| returns the point obtained by translating p by the vector v. | ||
| Point_3<Kernel> | operator- ( p, Vector_3<Kernel> v) | |
| returns the point obtained by translating p by the vector -v. | ||