CGAL 6.1.1 - 2D and 3D Linear Geometry Kernel

Loading...
Searching...
No Matches
List of all members | Related Functions
CGAL::Point_2< Kernel > Class Template Reference
Reference Manual » 2D Kernel Objects

`#include <CGAL/Point_2.h>`

## Definition

template<typename Kernel>
class CGAL::Point_2< Kernel >

An object `p` of the class `Point_2` is a point in the two-dimensional Euclidean plane \( \E^2\).

Remember that `Kernel::RT` and `Kernel::FT` denote a `RingNumberType` and a `FieldNumberType`, respectively. For the kernel model `Cartesian<NT>`, the two types are the same. For the kernel model `Homogeneous<NT>`, `Kernel::RT` is equal to `NT`, and `Kernel::FT` is equal to `Quotient<NT>`.

Example

The following declaration creates two points with Cartesian double coordinates.

Point_2< Cartesian<double> > p, q(1.0, 2.0);
CGAL::Point_2
An object p of the class Point_2 is a point in the two-dimensional Euclidean plane .
Definition: Point_2.h:37

The variable `p` is uninitialized and should first be used on the left hand side of an assignment.

p = q;
std::cout << p.x() << " " << p.y() << std::endl;
CGAL::Point_2::x
Kernel::FT x() const
returns the Cartesian coordinate, that is hx()/hw().
CGAL::Point_2::y
Kernel::FT y() const
returns the Cartesian coordinate, that is hy()/hw().

Is model of
  `Kernel::Point_2`
  `Hashable` if `Kernel` is a cartesian kernel and if `Kernel::FT` is `Hashable`

## Related Functions
(Note that these are not member functions.)
bool | operator< (const Point_2< Kernel > &p, const Point_2< Kernel > &q)
| returns true iff `p` is lexicographically smaller than `q`, i.e. either if `p.x() < q.x()` or if `p.x() == q.x()` and `p.y() < q.y()`.
bool | operator> (const Point_2< Kernel > &p, const Point_2< Kernel > &q)
| returns true iff `p` is lexicographically greater than `q`.
bool | operator<= (const Point_2< Kernel > &p, const Point_2< Kernel > &q)
| returns true iff `p` is lexicographically smaller or equal to `q`.
bool | operator>= (const Point_2< Kernel > &p, const Point_2< Kernel > &q)
| returns true iff `p` is lexicographically greater or equal to `q`.
Vector_2< Kernel > | operator- (const Point_2< Kernel > &p, const Point_2< Kernel > &q)
| returns the difference vector between `q` and `p`.

## Types
typedef unspecified_type | Cartesian_const_iterator
| An iterator for enumerating the Cartesian coordinates of a point.

## Creation
| Point_2 (const Origin &ORIGIN)
| introduces a variable `p` with Cartesian coordinates \( (0,0)\).
| Point_2 (int x, int y)
| introduces a point `p` initialized to `(x,y)`.
| Point_2 (double x, double y)
| introduces a point `p` initialized to `(x,y)` provided `RT` supports construction from `double`.
| Point_2 (const Kernel::RT &hx, const Kernel::RT &hy, const Kernel::RT &hw=RT(1))
| introduces a point `p` initialized to `(hx/hw,hy/hw)`.
| Point_2 (const Kernel::FT &x, const Kernel::FT &y)
| introduces a point `p` initialized to `(x,y)`.
| Point_2 (const Kernel::Weighted_point_2 &wp)
| introduces a point from a weighted point.

## Operations
bool | operator== (const Point_2< Kernel > &q) const
| Test for equality.
bool | operator!= (const Point_2< Kernel > &q) const
| Test for inequality.
Point_2< Kernel > & | operator+= (const Vector_2< Kernel > &v)
| translates the point by the vector `v`.
Point_2< Kernel > & | operator-= (const Vector_2< Kernel > &v)
| translates the point by the vector -`v`.

## Coordinate Access
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. Note that you do not lose information with the homogeneous representation, because the `FieldNumberType` is a quotient.
Kernel::RT | hx () const
| returns the homogeneous \( x\) coordinate.
Kernel::RT | hy () const
| returns the homogeneous \( y\) coordinate.
Kernel::RT | hw () const
| returns the homogenizing coordinate.
Kernel::FT | x () const
| returns the Cartesian \( x\) coordinate, that is `hx()`/`hw()`.
Kernel::FT | y () const
| returns the Cartesian \( y\) coordinate, that is `hy()`/`hw()`.

## Convenience Operations
The following operations are for convenience and for compatibility with higher dimensional points. Again they come in a Cartesian and in a homogeneous flavor.
Kernel::RT | homogeneous (int i) const
| returns the i-th homogeneous coordinate of `p`.
Kernel::FT | cartesian (int i) const
| returns the i-th Cartesian coordinate of `p`.
Kernel::FT | operator[] (int i) const
| returns `cartesian(i)`.
Cartesian_const_iterator | cartesian_begin () const
| returns an iterator to the Cartesian coordinates of `p`, starting with the 0th coordinate.
Cartesian_const_iterator | cartesian_end () const
| returns an off the end iterator to the Cartesian coordinates of `p`.
int | dimension () const
| returns the dimension (the constant 2).
Bbox_2 | bbox () const
| returns a bounding box containing `p`.
Point_2< Kernel > | transform (const Aff_transformation_2< Kernel > &t) const
| returns the point obtained by applying `t` on `p`.
Point_2< Kernel > | operator+ (const Point_2< Kernel > &p, const Vector_2< Kernel > &v)
| returns the point obtained by translating `p` by the vector `v`.
Point_2< Kernel > | operator- (const Point_2< Kernel > &p, const Vector_2< Kernel > &v)
| returns the point obtained by translating `p` by the vector -`v`.

## Constructor & Destructor Documentation

## ◆ Point_2() [1/5]

template<typename Kernel >

CGAL::Point_2< Kernel >::Point_2 | ( | const Origin & | ORIGIN | ) |

introduces a variable `p` with Cartesian coordinates \( (0,0)\).

Exactness
  This construction is trivial and therefore always exact in `Exact_predicates_inexact_constructions_kernel`.

## ◆ Point_2() [2/5]

template<typename Kernel >

CGAL::Point_2< Kernel >::Point_2 | ( | double | x,
|  | double | y
| ) |  |

introduces a point `p` initialized to `(x,y)` provided `RT` supports construction from `double`.

Exactness
  This construction is trivial and therefore always exact in `Exact_predicates_inexact_constructions_kernel`.

## ◆ Point_2() [3/5]

template<typename Kernel >

CGAL::Point_2< Kernel >::Point_2 | ( | const Kernel::RT & | hx,
|  | const Kernel::RT & | hy,
|  | const Kernel::RT & | hw = `RT(1)`
| ) |  |

introduces a point `p` initialized to `(hx/hw,hy/hw)`.

Precondition
  `hw != Kernel::RT(0)`.

## ◆ Point_2() [4/5]

template<typename Kernel >

CGAL::Point_2< Kernel >::Point_2 | ( | const Kernel::FT & | x,
|  | const Kernel::FT & | y
| ) |  |

introduces a point `p` initialized to `(x,y)`.

Exactness
  This construction is trivial and therefore always exact in `Exact_predicates_inexact_constructions_kernel`.

## ◆ Point_2() [5/5]

template<typename Kernel >

CGAL::Point_2< Kernel >::Point_2 | ( | const Kernel::Weighted_point_2 & | wp | ) |
| explicit

introduces a point from a weighted point.

Exactness
  This construction is trivial and therefore always exact in `Exact_predicates_inexact_constructions_kernel`.

Warning
  The `explicit` keyword is used to avoid accidental implicit conversions between Point_2 and Weighted_point_2.

## Member Function Documentation

## ◆ bbox()

template<typename Kernel >

Bbox_2 CGAL::Point_2< Kernel >::bbox | ( |  | ) | const

returns a bounding box containing `p`.

Exactness
  This construction is trivial and therefore always exact in `Exact_predicates_inexact_constructions_kernel`.

## ◆ cartesian()

template<typename Kernel >

Kernel::FT CGAL::Point_2< Kernel >::cartesian | ( | int | i | ) | const

returns the i-th Cartesian coordinate of `p`.

Precondition
  `0 <= i <= 1`.

Exactness
  This construction is trivial and therefore always exact in `Exact_predicates_inexact_constructions_kernel`.

## ◆ homogeneous()

template<typename Kernel >

Kernel::RT CGAL::Point_2< Kernel >::homogeneous | ( | int | i | ) | const

returns the i-th homogeneous coordinate of `p`.

Precondition
  `0 <= i <= 2`.

## ◆ operator!=()

template<typename Kernel >

bool CGAL::Point_2< Kernel >::operator!= | ( | const Point_2< Kernel > & | q | ) | const

Test for inequality.

The point can be compared with `ORIGIN`.

## ◆ operator==()

template<typename Kernel >

bool CGAL::Point_2< Kernel >::operator== | ( | const Point_2< Kernel > & | q | ) | const

Test for equality.

Two points are equal, iff their \( x\) and \( y\) coordinates are equal. The point can be compared with `ORIGIN`.

## ◆ operator[]()

template<typename Kernel >

Kernel::FT CGAL::Point_2< Kernel >::operator[] | ( | int | i | ) | const

returns `cartesian(i)`.

Precondition
  `0 <= i <= 1`.

Exactness
  This construction is trivial and therefore always exact in `Exact_predicates_inexact_constructions_kernel`.

## ◆ x()

template<typename Kernel >

Kernel::FT CGAL::Point_2< Kernel >::x | ( |  | ) | const

returns the Cartesian \( x\) coordinate, that is `hx()`/`hw()`.

Exactness
  This construction is trivial and therefore always exact in `Exact_predicates_inexact_constructions_kernel`.

## ◆ y()

template<typename Kernel >

Kernel::FT CGAL::Point_2< Kernel >::y | ( |  | ) | const

returns the Cartesian \( y\) coordinate, that is `hy()`/`hw()`.

Exactness
  This construction is trivial and therefore always exact in `Exact_predicates_inexact_constructions_kernel`.

## Friends And Related Function Documentation

## ◆ operator-()

template<typename Kernel >

Vector_2< Kernel > operator- | ( | const Point_2< Kernel > & | p,
|  | const Point_2< Kernel > & | q
| ) |  |
| related

returns the difference vector between `q` and `p`.

You can substitute `ORIGIN` for either `p` or `q`, but not for both.