Line segment (LineSegment)
LazySets.LineSegment
— TypeLineSegment{N, VN<:AbstractVector{N}} <: AbstractZonotope{N}
Type that represents a line segment in 2D between two points $p$ and $q$.
Fields
p
– first pointq
– second point
Examples
A line segment along the $x = y$ diagonal:
julia> s = LineSegment([0., 0], [1., 1.])
LineSegment{Float64, Vector{Float64}}([0.0, 0.0], [1.0, 1.0])
julia> dim(s)
2
Use plot(s)
to plot the extreme points of s
and the line segment joining them. If it is desired to remove the endpoints, pass the options markershape=:none
and seriestype=:shape
.
Membership is checked with ∈ (in
):
julia> [0., 0] ∈ s && [.25, .25] ∈ s && [1., 1] ∈ s && [.5, .25] ∉ s
true
We can check whether the intersection with another line segment is empty, and optionally compute a witness (which is the unique common point in this case):
julia> sn = LineSegment([1., 0], [0., 1.])
LineSegment{Float64, Vector{Float64}}([1.0, 0.0], [0.0, 1.0])
julia> isdisjoint(s, sn)
false
julia> isdisjoint(s, sn, true)
(false, [0.5, 0.5])
LazySets.API.dim
— Methoddim(L::LineSegment)
Return the ambient dimension of a 2D line segment.
Input
L
– 2D line segment
Output
The ambient dimension of the 2D line segment, which is $2$.
LazySets.API.σ
— Methodσ(d::AbstractVector, L::LineSegment)
Return the support vector of a 2D line segment in a given direction.
Input
d
– directionL
– 2D line segment
Output
The support vector in the given direction.
Algorithm
If the angle between the vector $q - p$ and $d$ is bigger than 90° and less than 270° (measured in counter-clockwise order), the result is $p$, otherwise it is $q$. If the angle is exactly 90° or 270°, or if the direction has norm zero, this implementation returns $q$.
LazySets.API.ρ
— Methodρ(d::AbstractVector, L::LineSegment)
Evaluate the support function of a 2D line segment in a given direction.
Input
d
– directionL
– 2D line segment
Output
Evaluation of the support function in the given direction.
Base.:∈
— Method∈(x::AbstractVector, L::LineSegment)
Check whether a given point is contained in a 2D line segment.
Input
x
– point/vectorL
– 2D line segment
Output
true
iff $x ∈ L$.
Algorithm
Let $L = (p, q)$ be the line segment with extreme points $p$ and $q$, and let $x$ be the given point.
- A necessary condition for $x ∈ (p, q)$ is that the three points are aligned, thus their cross product should be zero.
- It remains to check that $x$ belongs to the box approximation of $L$. This amounts to comparing each coordinate with those of the extremes $p$ and $q$.
Notes
The algorithm is inspired from here.
LazySets.center
— Methodcenter(L::LineSegment)
Return the center of a 2D line segment.
Input
L
– 2D line segment
Output
The center of the line segment.
LazySets.API.an_element
— Methodan_element(L::LineSegment)
Return some element of a 2D line segment.
Input
L
– 2D line segment
Output
The first vertex of the line segment.
Base.rand
— Methodrand(::Type{LineSegment}; [N]::Type{<:Real}=Float64, [dim]::Int=2,
[rng]::AbstractRNG=GLOBAL_RNG, [seed]::Union{Int, Nothing}=nothing)
Create a random 2D line segment.
Input
LineSegment
– type for dispatchN
– (optional, default:Float64
) numeric typedim
– (optional, default: 2) dimensionrng
– (optional, default:GLOBAL_RNG
) random number generatorseed
– (optional, default:nothing
) seed for reseeding
Output
A random 2D line segment.
Algorithm
All numbers are normally distributed with mean 0 and standard deviation 1.
LazySets.halfspace_left
— Methodhalfspace_left(L::LineSegment)
Return a half-space describing the 'left' of a two-dimensional 2D line segment through two points.
Input
L
– 2D line segment
Output
The half-space whose boundary goes through the two points p
and q
and which describes the left-hand side of the directed line segment pq
.
LazySets.halfspace_right
— Methodhalfspace_right(L::LineSegment)
Return a half-space describing the 'right' of a two-dimensional 2D line segment through two points.
Input
L
– 2D line segment
Output
The half-space whose boundary goes through the two points p
and q
and which describes the right-hand side of the directed line segment pq
.
LazySets.API.vertices_list
— Methodvertices_list(L::LineSegment)
Return the list of vertices of a 2D line segment.
Input
L
– 2D line segment
Output
The list of end points of the line segment.
LazySets.API.constraints_list
— Methodconstraints_list(L::LineSegment)
Return a list of constraints defining a 2D line segment in 2D.
Input
L
– 2D line segment
Output
A vector of constraints defining the line segment.
Algorithm
$L$ is defined by 4 constraints. In this algorithm, the first two constraints are returned by $halfspace_right$ and $halfspace_left$, and the other two are obtained by considering a vector parallel to the line segment passing through one of the vertices.
LazySets.API.translate
— Methodtranslate(L::LineSegment, v::AbstractVector)
Translate (i.e., shift) a 2D line segment by a given vector.
Input
L
– 2D line segmentv
– translation vector
Output
A translated line segment.
Algorithm
We add the vector to both defining points of the line segment.
LazySets.generators
— Methodgenerators(L::LineSegment)
Return an iterator over the (single) generator of a 2D line segment.
Input
L
– 2D line segment
Output
An iterator over the generator of L
, if any.
LazySets.ngens
— Methodngens(L::LineSegment)
Return the number of generators of a 2D line segment.
Input
L
– 2D line segment
Output
The number of generators.
Algorithm
A line segment has either one generator, or zero generators if it is a degenerated line segment of length zero.
LazySets.genmat
— Methodgenmat(L::LineSegment)
Return the generator matrix of a 2D line segment.
Input
L
– 2D line segment
Output
A matrix with at most one column representing the generator of L
.
Inherited from LazySet
:
Inherited from AbstractPolytope
:
Inherited from AbstractCentrallySymmetricPolytope
:
Inherited from AbstractZonotope
: