|
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.
| Segment_d<Kernel>::LA | |
|
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).
| |||
| 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).
| |||
| 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> | s.target () | 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.
| ||
| 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()). | ||
| Direction_d<Kernel> | s.direction () |
returns the direction from
source to target.
| ||
| 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.
| ||
| Line_d<Kernel> | s.supporting_line () |
returns the supporting line
of s.
| ||
| Segment_d<Kernel> | s.transform ( Aff_transformation_d<Kernel> t) | |||
returns t(s).
| ||||
| Segment_d<Kernel> | s + Vector_d<Kernel> v |
returns
s+v, i.e., s translated by vector v.
| ||
| bool | s.is_degenerate () | returns true if s is degenerate i.e. s.source()=s.target(). | ||
| bool | weak_equality ( s1, s2) |
Test for equality as unoriented
segments.
| ||
| bool | parallel ( s1, s2) |
return true if one of the segments is degenerate or if the
unoriented supporting lines are parallel.
| ||
| 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.
| ||||
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()).