Path package:diagrams-lib
A
path is a (possibly empty) list of
Located
Trails. Hence, unlike trails, paths are not translationally
invariant, and they form a monoid under
superposition (placing
one path on top of another) rather than concatenation.
This module defines
paths, which are collections of concretely
located
Trails. Many drawing systems (cairo, svg, ...) have a
similar notion of "path". Note that paths with multiple trails are
necessary for being able to draw
e.g. filled objects with holes
in them.
Paths in two dimensions are special since we may stroke them to create
a 2D diagram, and (eventually) perform operations such as intersection
and union. They also have a trace, whereas paths in higher dimensions
do not.
Compute the
centroid of a path (
i.e. the average
location of its
vertices; see
pathVertices).
Convert a located trail to a singleton path. This is equivalent to
trailLike, but provided with a more specific name and type for
convenience.
Convert a trail to a path beginning at the origin.
Convert a trail to a path with a particular starting point.
Convert a path into a list of lists of located segments.
Compute the total offset of each trail comprising a path (see
trailOffset).
Extract the located trails making up a
Path.
Extract the vertices of a path, resulting in a separate list of
vertices for each component trail. Here a
vertex is defined as
a non-differentiable point on the trail,
i.e. a sharp corner.
(Vertices are thus a subset of the places where segments join; if you
want all joins between segments, see
pathPoints.) The tolerance
determines how close the tangents of two segments must be at their
endpoints to consider the transition point to be differentiable. See
trailVertices for more information.
Extract the points of a path, resulting in a separate list of points
for each component trail. Here a
point is any place where two
segments join; see also
pathVertices and
trailPoints.
This function allows you "observe" the fact that trails are
implemented as lists of segments, which may be problematic if we want
to think of trails as parametric vector functions. This also means
that the behavior of this function may not be stable under future
changes to the implementation of trails and paths. For an
unproblematic version which only yields vertices at which there is a
sharp corner, excluding points differentiable points, see
pathVertices.
This function is not re-exported from
Diagrams.Prelude; to use
it, import
Diagrams.Path.
Type class for things that can be converted to a
Path.
Note that this class is very different from
TrailLike.
TrailLike is usually the result of a library function to give
you a convenient, polymorphic result (
Path,
Diagram
etc.).
"Explode" a path by exploding every component trail (see
explodeTrail).
Partition a path into two paths based on a predicate on trails: the
first containing all the trails for which the predicate returns
True, and the second containing the remaining trails.
Reverse all the component trails of a path.
Scale a path using its centroid (see
pathCentroid) as the base
point for the scale.
toPath takes something that can be converted to
Path and
returns the
Path.