Maintainer | diagrams-discuss@googlegroups.com |
---|
Generic functionality for constructing and manipulating trails (sequences of linear or cubic Bezier segments) and paths (collections of concretely located trails).
- class (Monoid p, VectorSpace (V p)) => PathLike p where
- fromSegments :: PathLike p => [Segment (V p)] -> p
- fromOffsets :: PathLike p => [V p] -> p
- fromVertices :: PathLike p => [Point (V p)] -> p
- segmentsFromVertices :: AdditiveGroup v => [Point v] -> [Segment v]
- pathLikeFromTrail :: PathLike p => Trail (V p) -> p
- class PathLike p => Closeable p where
- data Trail v = Trail {
- trailSegments :: [Segment v]
- isClosed :: Bool
- trailSegments' :: AdditiveGroup v => Trail v -> [Segment v]
- trailOffsets :: Trail v -> [v]
- trailOffset :: AdditiveGroup v => Trail v -> v
- trailVertices :: AdditiveGroup v => Point v -> Trail v -> [Point v]
- reverseTrail :: AdditiveGroup v => Trail v -> Trail v
- fixTrail :: AdditiveGroup v => Point v -> Trail v -> [FixedSegment v]
- newtype Path v = Path {
- pathTrails :: [(Point v, Trail v)]
- pathFromTrail :: AdditiveGroup v => Trail v -> Path v
- pathFromTrailAt :: Trail v -> Point v -> Path v
- pathVertices :: AdditiveGroup v => Path v -> [[Point v]]
- pathOffsets :: AdditiveGroup v => Path v -> [v]
- reversePath :: AdditiveGroup v => Path v -> Path v
- fixPath :: AdditiveGroup v => Path v -> [[FixedSegment v]]
- explodeTrail :: VectorSpace v => Point v -> Trail v -> [Path v]
- explodePath :: VectorSpace v => Path v -> [[Path v]]
- (~~) :: PathLike p => Point (V p) -> Point (V p) -> p
Constructing path-like things
class (Monoid p, VectorSpace (V p)) => PathLike p whereSource
Type class for path-like things, which must be monoids.
Instances include Trail
s, Path
s, and two-dimensional Diagram
s.
VectorSpace v => PathLike [Point v] | A list of points is path-like; this instance simply computes the vertices of a path-like thing. |
(Ord v, VectorSpace v) => PathLike (Path v) | Paths are (of course) path-like. |
VectorSpace v => PathLike (Trail v) | Trails are |
Renderable (Path R2) b => PathLike (AnnDiagram b R2 Any) |
fromSegments :: PathLike p => [Segment (V p)] -> pSource
Construct an open path-like thing with the origin as a starting point.
fromOffsets :: PathLike p => [V p] -> pSource
Construct an open path-like thing of linear segments from a list of offsets. The starting point is the origin.
fromVertices :: PathLike p => [Point (V p)] -> pSource
Construct a path-like thing of linear segments from a list of vertices, with the first vertex as the starting point.
segmentsFromVertices :: AdditiveGroup v => [Point v] -> [Segment v]Source
Construct a list of linear segments from a list of vertices. The input list must contain at least two points to generate a non-empty list of segments.
pathLikeFromTrail :: PathLike p => Trail (V p) -> pSource
Convert a trail to any path-like thing. pathLikeFromTrail
is the
identity on trails.
Closeable things
class PathLike p => Closeable p whereSource
Path-like things that can be "open" or "closed".
"Open" a path-like thing.
"Close" a path-like thing, by implicitly connecting the endpoint(s) back to the starting point(s).
(VectorSpace v, Ord v) => Closeable (Path v) | |
VectorSpace v => Closeable (Trail v) |
Trails
A trail is a sequence of segments placed end-to-end. Trails are thus translationally invariant, and form a monoid under concatenation. Trails can also be open (the default) or closed (the final point in a closed trail is implicitly connected back to the starting point).
Trail | |
|
Functor Trail | |
Eq v => Eq (Trail v) | |
Ord v => Ord (Trail v) | |
Show v => Show (Trail v) | |
Monoid (Trail v) | The empty trail has no segments. Trails are composed via
concatenation. |
(InnerSpace v, OrderedField (Scalar v)) => Boundable (Trail v) | The bounding function for a trail is based at the trail's start. |
HasLinearMap v => Transformable (Trail v) | |
VectorSpace v => Closeable (Trail v) | |
VectorSpace v => PathLike (Trail v) | Trails are |
(Show v, HasLinearMap v) => Renderable (Trail v) ShowBackend | |
Newtype (Path v) [(Point v, Trail v)] |
Computing with trails
trailSegments' :: AdditiveGroup v => Trail v -> [Segment v]Source
trailSegments'
is like trailSegments
, but explicitly includes
the implicit closing segment at the end of the list for closed trails.
trailOffsets :: Trail v -> [v]Source
Extract the offsets of the segments of a trail.
trailOffset :: AdditiveGroup v => Trail v -> vSource
Compute the offset from the start of a trail to the end.
trailVertices :: AdditiveGroup v => Point v -> Trail v -> [Point v]Source
Extract the vertices of a trail, given a concrete location at which to place the first vertex.
reverseTrail :: AdditiveGroup v => Trail v -> Trail vSource
Reverse a trail's direction of travel.
fixTrail :: AdditiveGroup v => Point v -> Trail v -> [FixedSegment v]Source
Convert a starting point and a trail into a list of fixed segments.
Paths
A path is a (possibly empty) list of trails, with each trail paired with an absolute starting point. Hence, paths are not translationally invariant, and form a monoid under superposition.
Path | |
|
Eq v => Eq (Path v) | |
Ord v => Ord (Path v) | |
Show v => Show (Path v) | |
Monoid (Path v) | |
(InnerSpace v, OrderedField (Scalar v)) => Boundable (Path v) | |
(HasLinearMap v, Ord v) => Transformable (Path v) | |
(Ord v, VectorSpace v) => HasOrigin (Path v) | |
(VectorSpace v, Ord v) => Closeable (Path v) | |
(Ord v, VectorSpace v) => PathLike (Path v) | Paths are (of course) path-like. |
(Ord v, Show v, HasLinearMap v) => Renderable (Path v) ShowBackend | |
Newtype (Path v) [(Point v, Trail v)] |
Constructing paths from trails
pathFromTrail :: AdditiveGroup v => Trail v -> Path vSource
Convert a trail to a path beginning at the origin.
pathFromTrailAt :: Trail v -> Point v -> Path vSource
Convert a trail to a path with a particular starting point.
Computing with paths
pathVertices :: AdditiveGroup v => Path v -> [[Point v]]Source
Extract the vertices of a path.
pathOffsets :: AdditiveGroup v => Path v -> [v]Source
Compute the total offset of each trail comprising a path.
reversePath :: AdditiveGroup v => Path v -> Path vSource
Reverse the direction of all the component trails of a path.
fixPath :: AdditiveGroup v => Path v -> [[FixedSegment v]]Source
Convert a path into a list of lists of FixedSegment
s.
Miscellaneous
explodeTrail :: VectorSpace v => Point v -> Trail v -> [Path v]Source
Given a starting point, "explode" a trail by turning each segment (including the implicit closing segment, if the trail is closed) into its own separate path. Useful for (say) applying a different style to each segment.
explodePath :: VectorSpace v => Path v -> [[Path v]]Source
"Explode" a path by exploding every component trail (see explodeTrail
).