CGAL 5.6.3 - 2D and 3D Linear Geometry Kernel

Loading...
Searching...
No Matches
List of all members
CGAL::Weighted_point_2< Kernel > Class Template Reference
2D and 3D Linear Geometry Kernel Reference » 2D Kernel Objects

`#include <CGAL/Weighted_point_2.h>`

## Definition

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

An object of the class `Weighted_point_2` is a tuple of a two-dimensional point and a scalar weight.

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>`.

See also
  `Point_2<Kernel>`

Is Model Of:

  `Kernel::WeightedPoint_2`

  `Hashable` if `Kernel` is a cartesian kernel and if `Kernel::FT` is `Hashable`

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

## Creation
Constructors from coordinates are provided for convenience, except that they are only from Cartesian coordinates, and with no weight, so as to avoid any potential ambiguity between the homogeneous weight and the power weight (it should be easy enough to pass a Point_2 explicitly in those cases).
| Weighted_point_2 (const Origin &ORIGIN)
| introduces a weighted point with Cartesian coordinates `(0,0)` and weight `0`.
| Weighted_point_2 (const Point_2< Kernel > &p)
| introduces a weighted point from point `p` and weight `0`.
| Weighted_point_2 (const Point_2< Kernel > &p, Kernel::FT &w)
| introduces a weighted point from point `p` and weight `w`.
| Weighted_point_2 (const Kernel::FT &x, const Kernel::FT &y)
| introduces a weighted point with coordinates `x`, `y`, and weight `0`.

## Bare point and weight accessors
Point_2< Kernel > | point () const
| returns the point of the weighted point.
Kernel::FT | weight () const
| returns the weight of the weighted point.

## Operations
Warning Comparison and equality operators (==, !=, <, etc.) currently operate directly on the underlying bare point. Consequently: Point_2< Cartesian<double> > p(1.0, 2.0); Weighted_point_2< Cartesian<double> > wp(p, 1.0), wq(p, 2.0); // same bare point, but different weights wp == wq; // is equal to `true` CGAL::Point_2 An object p of the class Point_2 is a point in the two-dimensional Euclidean plane . Definition: Point_2.h:38 CGAL::Weighted_point_2 An object of the class Weighted_point_2 is a tuple of a two-dimensional point and a scalar weight. Definition: Weighted_point_2.h:22
bool | operator== (const Weighted_point_2< Kernel > &q) const
| Test for equality.
bool | operator!= (const Weighted_point_2< Kernel > &q) const
| Test for inequality.

## 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`.
Weighted_point_2< Kernel > | transform (const Aff_transformation_2< Kernel > &t) const
| returns the weighted point obtained by applying `t` on `p`.

## Constructor & Destructor Documentation

## ◆ Weighted_point_2()

template<typename Kernel >

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

introduces a weighted point from point `p` and weight `0`.

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

## Member Function Documentation

## ◆ cartesian()

template<typename Kernel >

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

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

Precondition
  `0 <= i <= 1`

## ◆ homogeneous()

template<typename Kernel >

Kernel::RT CGAL::Weighted_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::Weighted_point_2< Kernel >::operator!= | ( | const Weighted_point_2< Kernel > & | q | ) | const

Test for inequality.

The point can be compared with `ORIGIN`.

## ◆ operator==()

template<typename Kernel >

bool CGAL::Weighted_point_2< Kernel >::operator== | ( | const Weighted_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::Weighted_point_2< Kernel >::operator[] | ( | int | i | ) | const

returns `cartesian(i)`.

Precondition
  `0 <= i <= 1`