\( \newcommand{\E}{\mathrm{E}} \) \( \newcommand{\A}{\mathrm{A}} \) \( \newcommand{\R}{\mathrm{R}} \) \( \newcommand{\N}{\mathrm{N}} \) \( \newcommand{\Q}{\mathrm{Q}} \) \( \newcommand{\Z}{\mathrm{Z}} \) \( \def\ccSum #1#2#3{ \sum_{#1}^{#2}{#3} } \def\ccProd #1#2#3{ \sum_{#1}^{#2}{#3} }\)
CGAL 5.0.2 - 2D and 3D Linear Geometry Kernel
List of all members
CGAL::Weighted_point_3< Kernel > Class Template Reference
2D and 3D Linear Geometry Kernel Reference » 3D Kernel Objects

#include <CGAL/Weighted_point_3.h>

Definition

An object of the class Weighted_point_3 is a tuple of a three-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_3<Kernel>
Is Model Of:

Kernel::WeightedPoint_3

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_3 explicitly in those cases).

 Weighted_point_3 (const Origin &ORIGIN)
 introduces a weighted point with Cartesian coordinates (0,0,0) and weight 0.
 
 Weighted_point_3 (const Point_3< Kernel > &p)
 introduces a weighted point from point p and weight 0. More...
 
 Weighted_point_3 (const Point_3< Kernel > &p, Kernel::FT &w)
 introduces a weighted point from point p and weight w.
 
 Weighted_point_3 (const Kernel::FT &x, const Kernel::FT &y, const Kernel::FT &z)
 introduces a weighted point with coordinates x, y, z and weight 0.
 

Bare point and weight accessors

Point_3< 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_3< Cartesian<double> > p(1.0, 2.0, 3.0);
Weighted_point_3< Cartesian<double> > wp(p, 1.0), wq(p, 2.0); // same bare point, but different weights
wp == wq; // is equal to `true`
bool operator== (const Weighted_point_3< Kernel > &q) const
 Test for equality. More...
 
bool operator!= (const Weighted_point_3< Kernel > &q) const
 Test for inequality. More...
 

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 hz () const
 returns the homogeneous \( z\) 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().
 
Kernel::FT z () const
 returns the Cartesian \( z\) coordinate, that is hz()/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. More...
 
Kernel::FT cartesian (int i) const
 returns the i'th Cartesian coordinate of p. More...
 
Kernel::FT operator[] (int i) const
 returns cartesian(i). More...
 
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 3).
 
Bbox_3 bbox () const
 returns a bounding box containing p.
 
Weighted_point_3< Kernel > transform (const Aff_transformation_3< Kernel > &t) const
 returns the weighted point obtained by applying t on p.
 

Constructor & Destructor Documentation

◆ Weighted_point_3()

template<typename Kernel >
CGAL::Weighted_point_3< Kernel >::Weighted_point_3 ( const Point_3< 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_3 and Weighted_point_3.

Member Function Documentation

◆ cartesian()

template<typename Kernel >
Kernel::FT CGAL::Weighted_point_3< Kernel >::cartesian ( int  i) const

returns the i'th Cartesian coordinate of p.

Precondition
\( 0\leq i \leq2\).

◆ homogeneous()

template<typename Kernel >
Kernel::RT CGAL::Weighted_point_3< Kernel >::homogeneous ( int  i) const

returns the i'th homogeneous coordinate of p.

Precondition
\( 0\leq i \leq3\).

◆ operator!=()

template<typename Kernel >
bool CGAL::Weighted_point_3< Kernel >::operator!= ( const Weighted_point_3< Kernel > &  q) const

Test for inequality.

The point can be compared with ORIGIN.

◆ operator==()

template<typename Kernel >
bool CGAL::Weighted_point_3< Kernel >::operator== ( const Weighted_point_3< Kernel > &  q) const

Test for equality.

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

◆ operator[]()

template<typename Kernel >
Kernel::FT CGAL::Weighted_point_3< Kernel >::operator[] ( int  i) const

returns cartesian(i).

Precondition
\( 0\leq i \leq2\).