CGAL 5.3.1 - dD Geometry Kernel
CGAL::Line_d< Kernel > Class Template Reference

#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< Kernelpoint (int i)
returns an arbitrary point on l. More...

Line_d< Kernelopposite ()
returns the line (point(2),point(1)) of opposite direction.

Direction_d< Kerneldirection ()
returns the direction of l.

Line_d< Kerneltransform (const Aff_transformation_d< Kernel > &t)
returns $$t(l)$$. More...

Line_d< Kerneloperator+ (const Vector_d< Kernel > &v)
returns l+v, i.e., l translated by vector $$v$$. More...

Point_d< Kernelprojection (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...

◆ Line_d() [1/3]

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.

◆ Line_d() [2/3]

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.

◆ Line_d() [3/3]

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.

◆ has_on()

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().

◆ operator+()

template<typename Kernel >
 Line_d 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().

◆ point()

template<typename Kernel >
 Point_d 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.

◆ projection()

template<typename Kernel >
 Point_d 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().

◆ transform()

template<typename Kernel >
 Line_d CGAL::Line_d< Kernel >::transform ( const Aff_transformation_d< Kernel > & t )

returns $$t(l)$$.

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

◆ parallel()

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().

◆ weak_equality()

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().