"Fossies" - the Fresh Open Source Software Archive

Member "doc_html/Kernel_23/classCGAL_1_1Plane__3.html" (8 Nov 2019, 42729 Bytes) of package /linux/misc/CGAL-5.0-doc_html.tar.xz:


Caution: In this restricted "Fossies" environment the current HTML page may not be correctly presentated and may have some non-functional links. You can here alternatively try to browse the pure source code or just view or download the uninterpreted raw source code. If the rendering is insufficient you may try to find and view the page on the project site itself.

\( \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 - 2D and 3D Linear Geometry Kernel
CGAL::Plane_3< Kernel > Class Template Reference

#include <CGAL/Plane_3.h>

Definition

An object h of the data type Plane_3 is an oriented plane in the three-dimensional Euclidean space \( \E^3\).

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 \( \E^3\) 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\).

Is Model Of:
Kernel::Plane_3

Creation

 Plane_3 (const Kernel::RT &a, const Kernel::RT &b, const Kernel::RT &c, const Kernel::RT &d)
 creates a plane h defined by the equation \( a\, px +b\, py +c\, pz + d = 0\). More...
 
 Plane_3 (const Point_3< Kernel > &p, const Point_3< Kernel > &q, const Point_3< Kernel > &r)
 creates a plane h passing through the points p, q and r. More...
 
 Plane_3 (const Point_3< Kernel > &p, const Vector_3< Kernel > &v)
 introduces a plane h that passes through point p and that is orthogonal to v.
 
 Plane_3 (const Point_3< Kernel > &p, const Direction_3< Kernel > &d)
 introduces a plane h that passes through point p and that has as an orthogonal direction equal to d.
 
 Plane_3 (const Line_3< Kernel > &l, const Point_3< Kernel > &p)
 introduces a plane h that is defined through the three points l.point(0), l.point(1) and p.
 
 Plane_3 (const Ray_3< Kernel > &r, const Point_3< Kernel > &p)
 introduces a plane h that is defined through the three points r.point(0), r.point(1) and p.
 
 Plane_3 (const Segment_3< Kernel > &s, const Point_3< Kernel > &p)
 introduces a plane h that is defined through the three points s.source(), s.target() and p.
 
 Plane_3 (const Circle_3< Kernel > &c)
 introduces a plane h that is defined as the plane containing the circle.
 

Operations

bool operator== (const Plane_3< Kernel > &h2) const
 Test for equality: two planes are equal, iff they have a non empty intersection and the same orientation.
 
bool operator!= (const Plane_3< Kernel > &h2) const
 Test for inequality.
 
Kernel::RT a () const
 returns the first coefficient of h.
 
Kernel::RT b () const
 returns the second coefficient of h.
 
Kernel::RT c () const
 returns the third coefficient of h.
 
Kernel::RT d () const
 returns the fourth coefficient of h.
 
Line_3< Kernelperpendicular_line (const Point_3< Kernel > &p) const
 returns the line that is perpendicular to h and that passes through point p. More...
 
Point_3< Kernelprojection (const Point_3< Kernel > &p) const
 returns the orthogonal projection of p on h.
 
Plane_3< Kernelopposite () const
 returns the plane with opposite orientation.
 
Point_3< Kernelpoint () const
 returns an arbitrary point on h.
 
Vector_3< Kernelorthogonal_vector () const
 returns a vector that is orthogonal to h and that is directed to the positive side of h.
 
Direction_3< Kernelorthogonal_direction () const
 returns the direction that is orthogonal to h and that is directed to the positive side of h.
 
Vector_3< Kernelbase1 () const
 returns a vector orthogonal to orthogonal_vector().
 
Vector_3< Kernelbase2 () const
 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.
 

2D Conversion

The following functions provide conversion between a plane and CGAL's two-dimensional space.

The transformation is affine, but not necessarily an isometry. This means, the transformation preserves combinatorics, but not distances.

Point_2< Kernelto_2d (const Point_3< Kernel > &p) const
 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.
 
Point_3< Kernelto_3d (const Point_2< Kernel > &p) const
 returns a point q, such that to_2d( to_3d( p )) is equal to p.
 

Predicates

Oriented_side oriented_side (const Point_3< Kernel > &p) const
 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.
 

Convenience Boolean Functions

bool has_on (const Point_3< Kernel > &p) const
 
bool has_on_positive_side (const Point_3< Kernel > &p) const
 
bool has_on_negative_side (const Point_3< Kernel > &p) const
 
bool has_on (const Line_3< Kernel > &l) const
 
bool has_on (const Circle_3< Kernel > &l) const
 
bool is_degenerate () const
 Plane h is degenerate, if the coefficients a, b, and c of the plane equation are zero.
 

Miscellaneous

Plane_3< Kerneltransform (const Aff_transformation_3< Kernel > &t) const
 returns the plane obtained by applying t on a point of h and the orthogonal direction of h.
 

Constructor & Destructor Documentation

◆ Plane_3() [1/2]

template<typename Kernel >
CGAL::Plane_3< Kernel >::Plane_3 ( const Kernel::RT a,
const Kernel::RT b,
const Kernel::RT c,
const Kernel::RT 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 = 0\).

◆ Plane_3() [2/2]

template<typename Kernel >
CGAL::Plane_3< Kernel >::Plane_3 ( const Point_3< Kernel > &  p,
const Point_3< Kernel > &  q,
const Point_3< Kernel > &  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.

Member Function Documentation

◆ perpendicular_line()

template<typename Kernel >
Line_3<Kernel> CGAL::Plane_3< Kernel >::perpendicular_line ( const Point_3< Kernel > &  p) const

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.