\( \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 4.6.1 - dD Geometry Kernel
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Groups Pages
List of all members | Related Functions
CGAL::Line_d< Kernel > Class Template Reference
Kernel Objects

#include <CGAL/Kernel_d/Line_d.h>

Definition

An instance of data type Line_d is an oriented line in \( d\)-dimensional Euclidean space.

Implementation

Lines are implemented by a pair of points as an item type. All operations like creation, initialization, tests, direction calculation, input and output on a line \( l\) take time \( O(l.dimension())\). dimension(), coordinate and point access, and identity test take constant time. The operations for intersection calculation also take time \( O(l.dimension())\). The space requirement is \( O(l.dimension())\).

Related Functions

(Note that these are not member functions.)

bool weak_equality (const Line_d< Kernel > &l1, const Line_d< Kernel > &l2)
 Test for equality as unoriented lines. More...
 
bool parallel (const Line_d< Kernel > &l1, const Line_d< Kernel > &l2)
 returns true if l1 and l2 are parallel as unoriented lines and false otherwise. More...
 

Types

typedef unspecified_type LA
 the linear algebra layer.
 

Creation

 Line_d ()
 introduces a variable l of type Line_d<Kernel>.
 
 Line_d (Point_d< Kernel > p, Point_d< Kernel > q)
 introduces a line through p and q and oriented from p to q. More...
 
 Line_d (Point_d< Kernel > p, Direction_d< Kernel > dir)
 introduces a line through p with direction dir. More...
 
 Line_d (Segment_d< Kernel > s)
 introduces a variable l of type Line_d<Kernel> and initializes it to the line through s.source() and s.target() with direction from s.source() to s.target(). More...
 
 Line_d (Ray_d< Kernel > r)
 introduces a variable l of type Line_d<Kernel> and initializes it to the line through r.point(1) and r.point(2).
 

Operations

int dimension ()
 returns the dimension of the ambient space.
 
Point_d< Kernel > point (int i)
 returns an arbitrary point on l. More...
 
Line_d< Kernel > opposite ()
 returns the line (point(2),point(1)) of opposite direction.
 
Direction_d< Kernel > direction ()
 returns the direction of l.
 
Line_d< Kernel > transform (const Aff_transformation_d< Kernel > &t)
 returns \( t(l)\). More...
 
Line_d< Kernel > operator+ (const Vector_d< Kernel > &v)
 returns l+v, i.e., l translated by vector \( v\). More...
 
Point_d< Kernel > projection (const Point_d< Kernel > &p)
 returns the point of intersection of l with the hyperplane that is orthogonal to l and that contains p. More...
 
bool has_on (const Point_d< Kernel > &p)
 returns true if \( p\) lies on l and false otherwise. More...
 

Constructor & Destructor Documentation

template<typename Kernel >
CGAL::Line_d< Kernel >::Line_d ( Point_d< Kernel >  p,
Point_d< Kernel >  q 
)

introduces a line through p and q and oriented from p to q.

Precondition
\( p\) and \( q\) are distinct and have the same dimension.
template<typename Kernel >
CGAL::Line_d< Kernel >::Line_d ( Point_d< Kernel >  p,
Direction_d< Kernel >  dir 
)

introduces a line through p with direction dir.

Precondition
p.dimension()==dir.dimension(), dir is not degenerate.
template<typename Kernel >
CGAL::Line_d< Kernel >::Line_d ( Segment_d< Kernel >  s)

introduces a variable l of type Line_d<Kernel> and initializes it to the line through s.source() and s.target() with direction from s.source() to s.target().

Precondition
\( s\) is not degenerate.

Member Function Documentation

template<typename Kernel >
bool CGAL::Line_d< Kernel >::has_on ( const Point_d< Kernel > &  p)

returns true if \( p\) lies on l and false otherwise.

Precondition
l.dimension()==p.dimension().
template<typename Kernel >
Line_d<Kernel> CGAL::Line_d< Kernel >::operator+ ( const Vector_d< Kernel > &  v)

returns l+v, i.e., l translated by vector \( v\).

Precondition
l.dimension()==v.dimension().
template<typename Kernel >
Point_d<Kernel> CGAL::Line_d< Kernel >::point ( int  i)

returns an arbitrary point on l.

It holds that point(i) == point(j), iff i==j. Furthermore, l is directed from point(i) to point(j), for all i < j.

template<typename Kernel >
Point_d<Kernel> CGAL::Line_d< Kernel >::projection ( const Point_d< Kernel > &  p)

returns the point of intersection of l with the hyperplane that is orthogonal to l and that contains p.

Precondition
l.dimension()==p.dimension().
template<typename Kernel >
Line_d<Kernel> CGAL::Line_d< Kernel >::transform ( const Aff_transformation_d< Kernel > &  t)

returns \( t(l)\).

Precondition
l.dimension()==t.dimension().

Friends And Related Function Documentation

template<typename Kernel >
bool parallel ( const Line_d< Kernel > &  l1,
const Line_d< Kernel > &  l2 
)
related

returns true if l1 and l2 are parallel as unoriented lines and false otherwise.

Precondition
l1.dimension()==l2.dimension().
template<typename Kernel >
bool weak_equality ( const Line_d< Kernel > &  l1,
const Line_d< Kernel > &  l2 
)
related

Test for equality as unoriented lines.

Precondition
l1.dimension()==l2.dimension().