Copyright | (C) Frank Staals |
---|---|
License | see the LICENSE file |
Maintainer | Frank Staals |
Safe Haskell | None |
Language | Haskell2010 |
Line segment data type and some basic functions on line segments
Synopsis
- data LineSegment d p r
- pattern LineSegment :: EndPoint (Point d r :+ p) -> EndPoint (Point d r :+ p) -> LineSegment d p r
- pattern LineSegment' :: (Point d r :+ p) -> (Point d r :+ p) -> LineSegment d p r
- pattern ClosedLineSegment :: (Point d r :+ p) -> (Point d r :+ p) -> LineSegment d p r
- endPoints :: Traversal (LineSegment d p r) (LineSegment d' q s) (Point d r :+ p) (Point d' s :+ q)
- _SubLine :: (Num r, Arity d) => Iso' (LineSegment d p r) (SubLine d p r r)
- pattern ClosedRange :: forall a. a -> a -> Range a
- pattern OpenRange :: forall a. a -> a -> Range a
- pattern Range' :: forall a. a -> a -> Range a
- clampTo :: Ord r => Range r -> r -> r
- clipLower :: Ord a => EndPoint a -> Range a -> Maybe (Range a)
- clipUpper :: Ord a => EndPoint a -> Range a -> Maybe (Range a)
- covers :: Ord a => Range a -> Range a -> Bool
- inRange :: Ord a => a -> Range a -> Bool
- isClosed :: EndPoint a -> Bool
- isOpen :: EndPoint a -> Bool
- isValid :: Ord a => Range a -> Bool
- lower :: Lens' (Range a) (EndPoint a)
- prettyShow :: Show a => Range a -> String
- shiftLeft :: Num r => r -> Range r -> Range r
- shiftRight :: Num r => r -> Range r -> Range r
- unEndPoint :: Lens (EndPoint a) (EndPoint b) a b
- upper :: Lens' (Range a) (EndPoint a)
- data EndPoint a
- data Range a = Range {}
- newtype Interval a r = GInterval {
- _unInterval :: Range (r :+ a)
- class HasEnd t where
- class HasStart t where
- type StartCore t
- type StartExtra t
- start :: Lens' t (StartCore t :+ StartExtra t)
- pattern Interval :: EndPoint (r :+ a) -> EndPoint (r :+ a) -> Interval a r
- pattern ClosedInterval :: (r :+ a) -> (r :+ a) -> Interval a r
- pattern OpenInterval :: (r :+ a) -> (r :+ a) -> Interval a r
- inInterval :: Ord r => r -> Interval a r -> Bool
- shiftLeft' :: Num r => r -> Interval a r -> Interval a r
- toLineSegment :: (Monoid p, Num r, Arity d) => Line d r -> LineSegment d p r
- onSegment :: (Ord r, Fractional r, Arity d) => Point d r -> LineSegment d p r -> Bool
- orderedEndPoints :: Ord r => LineSegment 2 p r -> (Point 2 r :+ p, Point 2 r :+ p)
- segmentLength :: (Arity d, Floating r) => LineSegment d p r -> r
- sqDistanceToSeg :: (Arity d, Fractional r, Ord r) => Point d r -> LineSegment d p r -> r
- sqDistanceToSegArg :: (Arity d, Fractional r, Ord r) => Point d r -> LineSegment d p r -> (r, Point d r)
- flipSegment :: LineSegment d p r -> LineSegment d p r
Documentation
data LineSegment d p r Source #
Line segments. LineSegments have a start and end point, both of which may contain additional data of type p. We can think of a Line-Segment being defined as
>>>
data LineSegment d p r = LineSegment (EndPoint (Point d r :+ p)) (EndPoint (Point d r :+ p))
Instances
pattern LineSegment :: EndPoint (Point d r :+ p) -> EndPoint (Point d r :+ p) -> LineSegment d p r Source #
Pattern that essentially models the line segment as a:
>>>
data LineSegment d p r = LineSegment (EndPoint (Point d r :+ p)) (EndPoint (Point d r :+ p))
pattern LineSegment' :: (Point d r :+ p) -> (Point d r :+ p) -> LineSegment d p r Source #
Gets the start and end point, but forgetting if they are open or closed.
pattern ClosedLineSegment :: (Point d r :+ p) -> (Point d r :+ p) -> LineSegment d p r Source #
endPoints :: Traversal (LineSegment d p r) (LineSegment d' q s) (Point d r :+ p) (Point d' s :+ q) Source #
Traversal to access the endpoints. Note that this traversal allows you to change more or less everything, even the dimension and the numeric type used, but it preservers if the segment is open or closed.
pattern ClosedRange :: forall a. a -> a -> Range a #
prettyShow :: Show a => Range a -> String #
shiftRight :: Num r => r -> Range r -> Range r #
unEndPoint :: Lens (EndPoint a) (EndPoint b) a b #
Instances
Functor EndPoint | |
Foldable EndPoint | |
Defined in Data.Range fold :: Monoid m => EndPoint m -> m # foldMap :: Monoid m => (a -> m) -> EndPoint a -> m # foldr :: (a -> b -> b) -> b -> EndPoint a -> b # foldr' :: (a -> b -> b) -> b -> EndPoint a -> b # foldl :: (b -> a -> b) -> b -> EndPoint a -> b # foldl' :: (b -> a -> b) -> b -> EndPoint a -> b # foldr1 :: (a -> a -> a) -> EndPoint a -> a # foldl1 :: (a -> a -> a) -> EndPoint a -> a # elem :: Eq a => a -> EndPoint a -> Bool # maximum :: Ord a => EndPoint a -> a # minimum :: Ord a => EndPoint a -> a # | |
Traversable EndPoint | |
Eq a => Eq (EndPoint a) | |
Ord a => Ord (EndPoint a) | |
Read a => Read (EndPoint a) | |
Show a => Show (EndPoint a) | |
Generic (EndPoint a) | |
NFData a => NFData (EndPoint a) | |
Defined in Data.Range | |
Arbitrary r => Arbitrary (EndPoint r) | |
type Rep (EndPoint a) | |
Defined in Data.Range type Rep (EndPoint a) = D1 (MetaData "EndPoint" "Data.Range" "hgeometry-combinatorial-0.9.0.0-inplace" False) (C1 (MetaCons "Open" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) :+: C1 (MetaCons "Closed" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))) |
Instances
Functor Range | |
Foldable Range | |
Defined in Data.Range fold :: Monoid m => Range m -> m # foldMap :: Monoid m => (a -> m) -> Range a -> m # foldr :: (a -> b -> b) -> b -> Range a -> b # foldr' :: (a -> b -> b) -> b -> Range a -> b # foldl :: (b -> a -> b) -> b -> Range a -> b # foldl' :: (b -> a -> b) -> b -> Range a -> b # foldr1 :: (a -> a -> a) -> Range a -> a # foldl1 :: (a -> a -> a) -> Range a -> a # elem :: Eq a => a -> Range a -> Bool # maximum :: Ord a => Range a -> a # minimum :: Ord a => Range a -> a # | |
Traversable Range | |
Eq a => Eq (Range a) | |
Show a => Show (Range a) | |
Generic (Range a) | |
NFData a => NFData (Range a) | |
Defined in Data.Range | |
(Arbitrary r, Ord r) => Arbitrary (Range r) | |
IntervalLike (Range r) Source # | |
Ord a => IsIntersectableWith (Range a) (Range a) | |
type Rep (Range a) | |
Defined in Data.Range type Rep (Range a) = D1 (MetaData "Range" "Data.Range" "hgeometry-combinatorial-0.9.0.0-inplace" False) (C1 (MetaCons "Range" PrefixI True) (S1 (MetaSel (Just "_lower") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (EndPoint a)) :*: S1 (MetaSel (Just "_upper") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (EndPoint a)))) | |
type NumType (Range a) Source # | |
Defined in Data.Geometry.Properties | |
type IntersectionOf (Range a) (Range a) | |
Defined in Data.Range |
An Interval is essentially a Range
but with possible payload
GInterval | |
|
Instances
Instances
HasEnd (Interval a r) Source # | |
HasEnd (LineSegment d p r) Source # | |
Defined in Data.Geometry.LineSegment type EndCore (LineSegment d p r) :: Type Source # type EndExtra (LineSegment d p r) :: Type Source # end :: Lens' (LineSegment d p r) (EndCore (LineSegment d p r) :+ EndExtra (LineSegment d p r)) Source # |
class HasStart t where Source #
start :: Lens' t (StartCore t :+ StartExtra t) Source #
Instances
HasStart (Interval a r) Source # | |
HasStart (HalfLine d r) Source # | |
HasStart (LineSegment d p r) Source # | |
Defined in Data.Geometry.LineSegment type StartCore (LineSegment d p r) :: Type Source # type StartExtra (LineSegment d p r) :: Type Source # start :: Lens' (LineSegment d p r) (StartCore (LineSegment d p r) :+ StartExtra (LineSegment d p r)) Source # |
pattern ClosedInterval :: (r :+ a) -> (r :+ a) -> Interval a r Source #
pattern OpenInterval :: (r :+ a) -> (r :+ a) -> Interval a r Source #
inInterval :: Ord r => r -> Interval a r -> Bool Source #
Test if a value lies in an interval. Note that the difference between inInterval and inRange is that the extra value is *not* used in the comparison with inInterval, whereas it is in inRange.
toLineSegment :: (Monoid p, Num r, Arity d) => Line d r -> LineSegment d p r Source #
Directly convert a line into a line segment.
onSegment :: (Ord r, Fractional r, Arity d) => Point d r -> LineSegment d p r -> Bool Source #
Test if a point lies on a line segment.
>>>
(point2 1 0) `onSegment` (ClosedLineSegment (origin :+ ()) (point2 2 0 :+ ()))
True>>>
(point2 1 1) `onSegment` (ClosedLineSegment (origin :+ ()) (point2 2 0 :+ ()))
False>>>
(point2 5 0) `onSegment` (ClosedLineSegment (origin :+ ()) (point2 2 0 :+ ()))
False>>>
(point2 (-1) 0) `onSegment` (ClosedLineSegment (origin :+ ()) (point2 2 0 :+ ()))
False>>>
(point2 1 1) `onSegment` (ClosedLineSegment (origin :+ ()) (point2 3 3 :+ ()))
True
Note that the segments are assumed to be closed. So the end points lie on the segment.
>>>
(point2 2 0) `onSegment` (ClosedLineSegment (origin :+ ()) (point2 2 0 :+ ()))
True>>>
origin `onSegment` (ClosedLineSegment (origin :+ ()) (point2 2 0 :+ ()))
True
This function works for arbitrary dimensons.
>>>
(point3 1 1 1) `onSegment` (ClosedLineSegment (origin :+ ()) (point3 3 3 3 :+ ()))
True>>>
(point3 1 2 1) `onSegment` (ClosedLineSegment (origin :+ ()) (point3 3 3 3 :+ ()))
False
orderedEndPoints :: Ord r => LineSegment 2 p r -> (Point 2 r :+ p, Point 2 r :+ p) Source #
The left and right end point (or left below right if they have equal x-coords)
segmentLength :: (Arity d, Floating r) => LineSegment d p r -> r Source #
Length of the line segment
sqDistanceToSeg :: (Arity d, Fractional r, Ord r) => Point d r -> LineSegment d p r -> r Source #
Squared distance from the point to the Segment s. The same remark as for
the sqDistanceToSegArg
applies here.
sqDistanceToSegArg :: (Arity d, Fractional r, Ord r) => Point d r -> LineSegment d p r -> (r, Point d r) Source #
Squared distance from the point to the Segment s, and the point on s realizing it. Note that if the segment is *open*, the closest point returned may be one of the (open) end points, even though technically the end point does not lie on the segment. (The true closest point then lies arbitrarily close to the end point).
flipSegment :: LineSegment d p r -> LineSegment d p r Source #
flips the start and end point of the segment