An instance s of the data type Segment_d is a directed straight line segment in d-dimensional Euclidean space connecting two points p and q. p is called the source point and q is called the target point of s, both points are called endpoints of s. A segment whose endpoints are equal is called degenerate.


the representation type.

the ring type.

the field type.

the linear algebra layer.


Segment_d<Kernel> s;
introduces a variable s of type Segment_d<Kernel>.

Segment_d<Kernel> s ( Point_d<Kernel> p, Point_d<Kernel> q);
introduces a variable s of type Segment_d<Kernel> which is initialized to the segment (p,q).
Precondition: p.dimension()==q.dimension().

Segment_d<Kernel> s ( Point_d<Kernel> p, Vector_d<Kernel> v);
introduces a variable s of type Segment_d<Kernel> which is initialized to the segment (p,p+v).
Precondition: p.dimension()==v.dimension().


int s.dimension () returns the dimension of the ambient space.

Point_d<Kernel> s.source () returns the source point of segment s.

Point_d<Kernel> () returns the target point of segment s.

Point_d<Kernel> s.vertex ( int i) returns source or target of s: vertex(0) returns the source, vertex(1) returns the target. The parameter i is taken modulo 2, which gives easy access to the other vertex.
Precondition: i 0.

Point_d<Kernel> s.point ( int i) returns vertex(i).

Point_d<Kernel> s [ int i] returns vertex(i).

Point_d<Kernel> s.min () returns the lexicographically smaller vertex.

Point_d<Kernel> s.max () returns the lexicographically larger vertex.

Segment_d<Kernel> s.opposite () returns the segment (target(),source()).

s.direction () returns the direction from source to target.
Precondition: s is non-degenerate.

Vector_d<Kernel> s.vector () returns the vector from source to target.

FT s.squared_length ()
returns the square of the length of s.

bool s.has_on ( Point_d<Kernel> p)
returns true if p lies on s and false otherwise.
Precondition: s.dimension()==p.dimension().

Line_d<Kernel> s.supporting_line ()
returns the supporting line of s.
Precondition: s is non-degenerate.

Segment_d<Kernel> s.transform ( Aff_transformation_d<Kernel> t)
returns t(s).
Precondition: s.dimension()==t.dimension().

Segment_d<Kernel> s + Vector_d<Kernel> v
returns s+v, i.e., s translated by vector v.
Precondition: s.dimension()==v.dimension().

bool s.is_degenerate () returns true if s is degenerate i.e. s.source()

Non-Member Functions

bool weak_equality ( s1, s2)
Test for equality as unoriented segments.
Precondition: s1.dimension()==s2.dimension().

bool parallel ( s1, s2)
return true if one of the segments is degenerate or if the unoriented supporting lines are parallel.
Precondition: s1.dimension()==s2.dimension().

bool common_endpoint ( s1, s2, Point_d<Kernel>& common)
if s1 and s2 touch in a common end point, this point is assigned to common and the result is true, otherwise the result is false. If s1==s2 then one of the endpoints is returned.
Precondition: s1.dimension()==s2.dimension().


Segments are implemented by a pair of points as an item type. All operations like creation, initialization, tests, the calculation of the direction and source - target vector, input and output on a segment s take time O(s.dimension()). dimension(), coordinate and end point access, and identity test take constant time. The operations for intersection calculation also take time O(s.dimension()). The space requirement is O(s.dimension()).