| Copyright | (c) 2011-2015 diagrams-core team (see LICENSE) |
|---|---|
| License | BSD-style (see LICENSE) |
| Maintainer | diagrams-discuss@googlegroups.com |
| Safe Haskell | Safe-Inferred |
| Language | Haskell2010 |
Diagrams.Core
Description
The core library of primitives forming the basis of an embedded
domain-specific language for describing and rendering diagrams.
Normal users of the diagrams library should almost never need to
import anything from this package directly; instead, import modules
(especially Diagrams.Prelude) from the diagrams-lib package,
which re-exports most things of value to users.
For most library code needing access to core internals, it should be sufficient to import this module, which simply re-exports useful functionality from other modules in the core library. Library writers needing finer-grained access or functionality may occasionally find it useful to directly import one of the constituent core modules.
The diagrams library relies heavily on custom types and classes. Many
of the relevant definitions are in the Diagrams.Core.Types module.
Indeed the definition of the diagram type QDiagram is contained in:
QDiagram.
The best place to start when learning about diagrams' types is the user manual: https://diagrams.github.io/doc/manual.html#type-reference The following list shows which types are contained in each module of Diagrams.Core.
AnnotationUpAnnotsb v n mDownAnnotsv nQDiaLeafb v n mMeasurenSubdiagramb v n mSubMapb v n mPrimb v nBackendb v nDNodeb v n aDTreeb v n aRNodeb v n aRTreeb v n aNullBackendRenderablet bDv n
Envelopev nEnvelopedaOrderedFields
Juxtaposablea
ANameNameIsNameaQualifiableq
HasOrigint
Queryv n m
AttributeClassaAttributev nStylev nHasStyle
SortedListaTracev nTraceda
u,:-:vHasLinearMapHasBasisTransformationv nTransformabletTransInvt
Synopsis
- type family V a :: Type -> Type
- type family N a :: Type
- type Vn a = V a (N a)
- type InSpace v n a = (V a ~ v, N a ~ n, Additive v, Num n)
- type SameSpace a b = (V a ~ V b, N a ~ N b)
- data Point (f :: Type -> Type) a
- origin :: forall (f :: Type -> Type) a. (Additive f, Num a) => Point f a
- (*.) :: (Functor v, Num n) => n -> Point v n -> Point v n
- relative :: forall (f :: Type -> Type) a. (Additive f, Num a) => Point f a -> Iso' (Point f a) (f a)
- basis :: (Additive t, Traversable t, Num a) => [t a]
- dimension :: forall a. (Additive (V a), Traversable (V a)) => a -> Int
- determinant :: (Additive v, Traversable v, Num n) => Transformation v n -> n
- isReflection :: (Additive v, Traversable v, Num n, Ord n) => Transformation v n -> Bool
- data u :-: v
- (<->) :: (u -> v) -> (v -> u) -> u :-: v
- linv :: (u :-: v) -> v :-: u
- lapp :: (u :-: v) -> u -> v
- data Transformation v n
- inv :: (Functor v, Num n) => Transformation v n -> Transformation v n
- transp :: Transformation v n -> v n :-: v n
- transl :: Transformation v n -> v n
- dropTransl :: (Additive v, Num n) => Transformation v n -> Transformation v n
- apply :: Transformation v n -> v n -> v n
- papply :: (Additive v, Num n) => Transformation v n -> Point v n -> Point v n
- fromLinear :: (Additive v, Num n) => (v n :-: v n) -> (v n :-: v n) -> Transformation v n
- translation :: v n -> Transformation v n
- translate :: Transformable t => Vn t -> t -> t
- moveTo :: (InSpace v n t, HasOrigin t) => Point v n -> t -> t
- place :: (InSpace v n t, HasOrigin t) => t -> Point v n -> t
- scaling :: (Additive v, Fractional n) => n -> Transformation v n
- scale :: (InSpace v n a, Eq n, Fractional n, Transformable a) => n -> a -> a
- avgScale :: (Additive v, Traversable v, Floating n) => Transformation v n -> n
- class Transformable t where
- transform :: Transformation (V t) (N t) -> t -> t
- newtype TransInv t = TransInv t
- eye :: (HasBasis v, Num n) => v (v n)
- data AName
- data Name
- class (Typeable a, Ord a, Show a) => IsName a where
- class Qualifiable q where
- (.>) :: (IsName a1, IsName a2) => a1 -> a2 -> Name
- eachName :: (Typeable a, Ord a, Show a) => Traversal' Name a
- newtype SubMap b v n m = SubMap (Map Name [Subdiagram b v n m])
- fromNames :: IsName a => [(a, Subdiagram b v n m)] -> SubMap b v n m
- rememberAs :: IsName a => a -> QDiagram b v n m -> SubMap b v n m -> SubMap b v n m
- lookupSub :: IsName nm => nm -> SubMap b v n m -> Maybe [Subdiagram b v n m]
- class (Typeable a, Semigroup a) => AttributeClass a
- data Attribute (v :: Type -> Type) n :: Type where
- Attribute :: AttributeClass a => a -> Attribute v n
- MAttribute :: AttributeClass a => Measured n a -> Attribute v n
- TAttribute :: (AttributeClass a, Transformable a, V a ~ v, N a ~ n) => a -> Attribute v n
- data Style v n
- class HasStyle a where
- applyStyle :: Style (V a) (N a) -> a -> a
- getAttr :: forall a v n. AttributeClass a => Style v n -> Maybe a
- atAttr :: AttributeClass a => Lens' (Style v n) (Maybe a)
- atMAttr :: (AttributeClass a, Typeable n) => Lens' (Style v n) (Maybe (Measured n a))
- atTAttr :: (V a ~ v, N a ~ n, AttributeClass a, Transformable a) => Lens' (Style v n) (Maybe a)
- applyAttr :: (AttributeClass a, HasStyle d) => a -> d -> d
- applyMAttr :: (AttributeClass a, N d ~ n, HasStyle d) => Measured n a -> d -> d
- applyTAttr :: (AttributeClass a, Transformable a, V a ~ V d, N a ~ N d, HasStyle d) => a -> d -> d
- newtype Envelope v n = Envelope (Maybe (v n -> Max n))
- appEnvelope :: Envelope v n -> Maybe (v n -> n)
- onEnvelope :: ((v n -> n) -> v n -> n) -> Envelope v n -> Envelope v n
- mkEnvelope :: (v n -> n) -> Envelope v n
- class (Metric (V a), OrderedField (N a)) => Enveloped a where
- getEnvelope :: a -> Envelope (V a) (N a)
- envelopeVMay :: Enveloped a => Vn a -> a -> Maybe (Vn a)
- envelopeV :: Enveloped a => Vn a -> a -> Vn a
- envelopePMay :: (V a ~ v, N a ~ n, Enveloped a) => v n -> a -> Maybe (Point v n)
- envelopeP :: (V a ~ v, N a ~ n, Enveloped a) => v n -> a -> Point v n
- diameter :: (V a ~ v, N a ~ n, Enveloped a) => v n -> a -> n
- radius :: (V a ~ v, N a ~ n, Enveloped a) => v n -> a -> n
- size :: (V a ~ v, N a ~ n, Enveloped a, HasBasis v) => a -> v n
- newtype Trace v n = Trace (Point v n -> v n -> SortedList n)
- data SortedList a
- mkSortedList :: Ord a => [a] -> SortedList a
- getSortedList :: SortedList a -> [a]
- appTrace :: Trace v n -> Point v n -> v n -> SortedList n
- mkTrace :: (Point v n -> v n -> SortedList n) -> Trace v n
- class (Additive (V a), Ord (N a)) => Traced a where
- traceV :: (n ~ N a, Num n, Traced a) => Point (V a) n -> V a n -> a -> Maybe (V a n)
- traceP :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (Point (V a) n)
- maxTraceV :: (n ~ N a, Num n, Traced a) => Point (V a) n -> V a n -> a -> Maybe (V a n)
- maxTraceP :: (n ~ N a, Num n, Traced a) => Point (V a) n -> V a n -> a -> Maybe (Point (V a) n)
- rayTraceV :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (V a n)
- rayTraceP :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (Point (V a) n)
- maxRayTraceV :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (V a n)
- maxRayTraceP :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (Point (V a) n)
- class HasOrigin t where
- moveOriginTo :: Point (V t) (N t) -> t -> t
- moveOriginBy :: (V t ~ v, N t ~ n, HasOrigin t) => v n -> t -> t
- class Juxtaposable a where
- juxtaposeDefault :: (Enveloped a, HasOrigin a) => Vn a -> a -> a -> a
- newtype Query v n m = Query {}
- data Prim b v n where
- Prim :: (Transformable p, Typeable p, Renderable p b) => p -> Prim b (V p) (N p)
- data QDiagram b v n m
- type Diagram b = QDiagram b (V b) (N b) Any
- mkQD :: Prim b v n -> Envelope v n -> Trace v n -> SubMap b v n m -> Query v n m -> QDiagram b v n m
- pointDiagram :: (Metric v, Fractional n) => Point v n -> QDiagram b v n m
- envelope :: (OrderedField n, Metric v, Monoid' m) => Lens' (QDiagram b v n m) (Envelope v n)
- trace :: (Metric v, OrderedField n, Semigroup m) => Lens' (QDiagram b v n m) (Trace v n)
- subMap :: (Metric v, Semigroup m, OrderedField n) => Lens' (QDiagram b v n m) (SubMap b v n m)
- names :: (Metric v, Semigroup m, OrderedField n) => QDiagram b v n m -> [(Name, [Point v n])]
- query :: Monoid m => QDiagram b v n m -> Query v n m
- nameSub :: (IsName nm, Metric v, OrderedField n, Semigroup m) => (QDiagram b v n m -> Subdiagram b v n m) -> nm -> QDiagram b v n m -> QDiagram b v n m
- withName :: (IsName nm, Metric v, Semigroup m, OrderedField n) => nm -> (Subdiagram b v n m -> QDiagram b v n m -> QDiagram b v n m) -> QDiagram b v n m -> QDiagram b v n m
- withNameAll :: (IsName nm, Metric v, Semigroup m, OrderedField n) => nm -> ([Subdiagram b v n m] -> QDiagram b v n m -> QDiagram b v n m) -> QDiagram b v n m -> QDiagram b v n m
- withNames :: (IsName nm, Metric v, Semigroup m, OrderedField n) => [nm] -> ([Subdiagram b v n m] -> QDiagram b v n m -> QDiagram b v n m) -> QDiagram b v n m -> QDiagram b v n m
- localize :: forall b v n m. (Metric v, OrderedField n, Semigroup m) => QDiagram b v n m -> QDiagram b v n m
- href :: (Metric v, OrderedField n, Semigroup m) => String -> QDiagram b v n m -> QDiagram b v n m
- opacityGroup :: (Metric v, OrderedField n, Semigroup m) => Double -> QDiagram b v n m -> QDiagram b v n m
- groupOpacity :: (Metric v, OrderedField n, Semigroup m) => Double -> QDiagram b v n m -> QDiagram b v n m
- setEnvelope :: forall b v n m. (OrderedField n, Metric v, Monoid' m) => Envelope v n -> QDiagram b v n m -> QDiagram b v n m
- setTrace :: forall b v n m. (OrderedField n, Metric v, Semigroup m) => Trace v n -> QDiagram b v n m -> QDiagram b v n m
- atop :: (OrderedField n, Metric v, Semigroup m) => QDiagram b v n m -> QDiagram b v n m -> QDiagram b v n m
- data Subdiagram b v n m = Subdiagram (QDiagram b v n m) (DownAnnots v n)
- mkSubdiagram :: QDiagram b v n m -> Subdiagram b v n m
- getSub :: (Metric v, OrderedField n, Semigroup m) => Subdiagram b v n m -> QDiagram b v n m
- rawSub :: Subdiagram b v n m -> QDiagram b v n m
- location :: (Additive v, Num n) => Subdiagram b v n m -> Point v n
- subPoint :: (Metric v, OrderedField n) => Point v n -> Subdiagram b v n m
- data Measured n a
- type Measure n = Measured n n
- fromMeasured :: Num n => n -> n -> Measured n a -> a
- output :: n -> Measure n
- local :: Num n => n -> Measure n
- global :: Num n => n -> Measure n
- normalized :: Num n => n -> Measure n
- scaleLocal :: Num n => n -> Measured n a -> Measured n a
- atLeast :: Ord n => Measure n -> Measure n -> Measure n
- atMost :: Ord n => Measure n -> Measure n -> Measure n
- class Backend b v n where
- class Transformable t => Renderable t b where
- renderDia :: (Backend b v n, HasLinearMap v, Metric v, Typeable n, OrderedField n, Monoid' m) => b -> Options b v n -> QDiagram b v n m -> Result b v n
- renderDiaT :: (Backend b v n, HasLinearMap v, Metric v, Typeable n, OrderedField n, Monoid' m) => b -> Options b v n -> QDiagram b v n m -> (Transformation v n, Result b v n)
- data NullBackend
- type D v n = QDiagram NullBackend v n Any
- type HasLinearMap v = (HasBasis v, Traversable v)
- type HasBasis v = (Additive v, Representable v, Rep v ~ E v)
- type OrderedField s = (Floating s, Ord s)
- type TypeableFloat n = (Typeable n, RealFloat n)
- type Monoid' = Monoid
Associated vector spaces
type family V a :: Type -> Type Source #
Many sorts of objects have an associated vector space in which
they "live". The type function V maps from object types to
the associated vector space. The resulting vector space has kind * -> *
which means it takes another value (a number) and returns a concrete
vector. For example V2 has kind * -> * and V2 Double is a vector.
Instances
type family N a :: Type Source #
The numerical field for the object, the number type used for calculations.
Instances
type Vn a = V a (N a) Source #
Convenient type alias to retrieve the vector type associated with an
object's vector space. This is usually used as Vn a ~ v n where v is
the vector space and n is the numerical field.
type SameSpace a b = (V a ~ V b, N a ~ N b) Source #
SameSpace a b means the types a and b belong to the same
vector space v n.
Points
data Point (f :: Type -> Type) a #
A handy wrapper to help distinguish points from vectors at the type level
Instances
| Generic1 (Point f :: Type -> Type) | |
| Unbox (f a) => Vector Vector (Point f a) | |
Defined in Linear.Affine Methods basicUnsafeFreeze :: Mutable Vector s (Point f a) -> ST s (Vector (Point f a)) # basicUnsafeThaw :: Vector (Point f a) -> ST s (Mutable Vector s (Point f a)) # basicLength :: Vector (Point f a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Point f a) -> Vector (Point f a) # basicUnsafeIndexM :: Vector (Point f a) -> Int -> Box (Point f a) # basicUnsafeCopy :: Mutable Vector s (Point f a) -> Vector (Point f a) -> ST s () # | |
| Unbox (f a) => MVector MVector (Point f a) | |
Defined in Linear.Affine Methods basicLength :: MVector s (Point f a) -> Int # basicUnsafeSlice :: Int -> Int -> MVector s (Point f a) -> MVector s (Point f a) # basicOverlaps :: MVector s (Point f a) -> MVector s (Point f a) -> Bool # basicUnsafeNew :: Int -> ST s (MVector s (Point f a)) # basicInitialize :: MVector s (Point f a) -> ST s () # basicUnsafeReplicate :: Int -> Point f a -> ST s (MVector s (Point f a)) # basicUnsafeRead :: MVector s (Point f a) -> Int -> ST s (Point f a) # basicUnsafeWrite :: MVector s (Point f a) -> Int -> Point f a -> ST s () # basicClear :: MVector s (Point f a) -> ST s () # basicSet :: MVector s (Point f a) -> Point f a -> ST s () # basicUnsafeCopy :: MVector s (Point f a) -> MVector s (Point f a) -> ST s () # basicUnsafeMove :: MVector s (Point f a) -> MVector s (Point f a) -> ST s () # basicUnsafeGrow :: MVector s (Point f a) -> Int -> ST s (MVector s (Point f a)) # | |
| Representable f => Representable (Point f) | |
| Foldable f => Foldable (Point f) | |
Defined in Linear.Affine Methods fold :: Monoid m => Point f m -> m # foldMap :: Monoid m => (a -> m) -> Point f a -> m # foldMap' :: Monoid m => (a -> m) -> Point f a -> m # foldr :: (a -> b -> b) -> b -> Point f a -> b # foldr' :: (a -> b -> b) -> b -> Point f a -> b # foldl :: (b -> a -> b) -> b -> Point f a -> b # foldl' :: (b -> a -> b) -> b -> Point f a -> b # foldr1 :: (a -> a -> a) -> Point f a -> a # foldl1 :: (a -> a -> a) -> Point f a -> a # elem :: Eq a => a -> Point f a -> Bool # maximum :: Ord a => Point f a -> a # minimum :: Ord a => Point f a -> a # | |
| Eq1 f => Eq1 (Point f) | |
| Ord1 f => Ord1 (Point f) | |
Defined in Linear.Affine | |
| Read1 f => Read1 (Point f) | |
Defined in Linear.Affine | |
| Show1 f => Show1 (Point f) | |
| Traversable f => Traversable (Point f) | |
| Applicative f => Applicative (Point f) | |
| Functor f => Functor (Point f) | |
| Monad f => Monad (Point f) | |
| Serial1 f => Serial1 (Point f) | |
Defined in Linear.Affine Methods serializeWith :: MonadPut m => (a -> m ()) -> Point f a -> m () # deserializeWith :: MonadGet m => m a -> m (Point f a) # | |
| Distributive f => Distributive (Point f) | |
| Hashable1 f => Hashable1 (Point f) | |
Defined in Linear.Affine | |
| Additive f => Affine (Point f) | |
| Metric f => Metric (Point f) | |
Defined in Linear.Affine | |
| Finite f => Finite (Point f) | |
| R1 f => R1 (Point f) | |
Defined in Linear.Affine | |
| R2 f => R2 (Point f) | |
| R3 f => R3 (Point f) | |
| R4 f => R4 (Point f) | |
| Additive f => Additive (Point f) | |
Defined in Linear.Affine Methods (^+^) :: Num a => Point f a -> Point f a -> Point f a # (^-^) :: Num a => Point f a -> Point f a -> Point f a # lerp :: Num a => a -> Point f a -> Point f a -> Point f a # liftU2 :: (a -> a -> a) -> Point f a -> Point f a -> Point f a # liftI2 :: (a -> b -> c) -> Point f a -> Point f b -> Point f c # | |
| Apply f => Apply (Point f) | |
| Bind f => Bind (Point f) | |
| Functor v => Cosieve (Query v) (Point v) Source # | |
Defined in Diagrams.Core.Query | |
| (Typeable f, Typeable a, Data (f a)) => Data (Point f a) | |
Defined in Linear.Affine Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Point f a -> c (Point f a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Point f a) # toConstr :: Point f a -> Constr # dataTypeOf :: Point f a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Point f a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Point f a)) # gmapT :: (forall b. Data b => b -> b) -> Point f a -> Point f a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Point f a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Point f a -> r # gmapQ :: (forall d. Data d => d -> u) -> Point f a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Point f a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Point f a -> m (Point f a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Point f a -> m (Point f a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Point f a -> m (Point f a) # | |
| Storable (f a) => Storable (Point f a) | |
Defined in Linear.Affine | |
| Monoid (f a) => Monoid (Point f a) | |
| Semigroup (f a) => Semigroup (Point f a) | |
| Generic (Point f a) | |
| Ix (f a) => Ix (Point f a) | |
Defined in Linear.Affine Methods range :: (Point f a, Point f a) -> [Point f a] # index :: (Point f a, Point f a) -> Point f a -> Int # unsafeIndex :: (Point f a, Point f a) -> Point f a -> Int # inRange :: (Point f a, Point f a) -> Point f a -> Bool # rangeSize :: (Point f a, Point f a) -> Int # unsafeRangeSize :: (Point f a, Point f a) -> Int # | |
| Num (f a) => Num (Point f a) | |
Defined in Linear.Affine | |
| Read (f a) => Read (Point f a) | |
| Fractional (f a) => Fractional (Point f a) | |
| Show (f a) => Show (Point f a) | |
| Binary (f a) => Binary (Point f a) | |
| Serial (f a) => Serial (Point f a) | |
Defined in Linear.Affine | |
| Serialize (f a) => Serialize (Point f a) | |
| NFData (f a) => NFData (Point f a) | |
Defined in Linear.Affine | |
| (OrderedField n, Metric v) => Enveloped (Point v n) Source # | |
Defined in Diagrams.Core.Envelope | |
| (Additive v, Num n) => HasOrigin (Point v n) Source # | |
| (Additive v, Ord n) => Traced (Point v n) Source # | The trace of a single point is the empty trace, i.e. the one which returns no intersection points for every query. Arguably it should return a single finite distance for vectors aimed directly at the given point, but due to floating-point inaccuracy this is problematic. Note that the envelope for a single point is not the empty envelope (see Diagrams.Core.Envelope). |
| (Additive v, Num n) => Transformable (Point v n) Source # | |
| Eq (f a) => Eq (Point f a) | |
| Ord (f a) => Ord (Point f a) | |
| Hashable (f a) => Hashable (Point f a) | |
Defined in Linear.Affine | |
| Ixed (f a) => Ixed (Point f a) | |
Defined in Linear.Affine | |
| Wrapped (Point f a) | |
| Epsilon (f a) => Epsilon (Point f a) | |
Defined in Linear.Affine | |
| Random (f a) => Random (Point f a) | |
| Unbox (f a) => Unbox (Point f a) | |
Defined in Linear.Affine | |
| t ~ Point g b => Rewrapped (Point f a) t | |
Defined in Linear.Affine | |
| Traversable f => Each (Point f a) (Point f b) a b | |
| type Rep1 (Point f :: Type -> Type) | |
| newtype MVector s (Point f a) | |
Defined in Linear.Affine | |
| type Rep (Point f) | |
Defined in Linear.Affine | |
| type Diff (Point f) | |
Defined in Linear.Affine | |
| type Size (Point f) | |
Defined in Linear.Affine | |
| type Rep (Point f a) | |
Defined in Linear.Affine | |
| type N (Point v n) Source # | |
Defined in Diagrams.Core.Points | |
| type V (Point v n) Source # | |
Defined in Diagrams.Core.Points | |
| type Index (Point f a) | |
Defined in Linear.Affine | |
| type IxValue (Point f a) | |
Defined in Linear.Affine | |
| type Unwrapped (Point f a) | |
Defined in Linear.Affine | |
| newtype Vector (Point f a) | |
Defined in Linear.Affine | |
origin :: forall (f :: Type -> Type) a. (Additive f, Num a) => Point f a #
Vector spaces have origins.
(*.) :: (Functor v, Num n) => n -> Point v n -> Point v n Source #
Scale a point by a scalar. Specialized version of (*^).
relative :: forall (f :: Type -> Type) a. (Additive f, Num a) => Point f a -> Iso' (Point f a) (f a) #
An isomorphism between points and vectors, given a reference point.
Transformations
Utilities
basis :: (Additive t, Traversable t, Num a) => [t a] #
Produce a default basis for a vector space. If the dimensionality
of the vector space is not statically known, see basisFor.
dimension :: forall a. (Additive (V a), Traversable (V a)) => a -> Int Source #
Get the dimension of an object whose vector space is an instance of
HasLinearMap, e.g. transformations, paths, diagrams, etc.
determinant :: (Additive v, Traversable v, Num n) => Transformation v n -> n Source #
The determinant of (the linear part of) a Transformation.
isReflection :: (Additive v, Traversable v, Num n, Ord n) => Transformation v n -> Bool Source #
Determine whether a Transformation includes a reflection
component, that is, whether it reverses orientation.
Invertible linear transformations
data u :-: v infixr 7 Source #
(v1 :-: v2) is a linear map paired with its inverse.
(<->) :: (u -> v) -> (v -> u) -> u :-: v Source #
Create an invertible linear map from two functions which are assumed to be linear inverses.
General transformations
data Transformation v n Source #
General (affine) transformations, represented by an invertible linear map, its transpose, and a vector representing a translation component.
By the transpose of a linear map we mean simply the linear map corresponding to the transpose of the map's matrix representation. For example, any scale is its own transpose, since scales are represented by matrices with zeros everywhere except the diagonal. The transpose of a rotation is the same as its inverse.
The reason we need to keep track of transposes is because it turns out that when transforming a shape according to some linear map L, the shape's normal vectors transform according to L's inverse transpose. (For a more detailed explanation and proof, see https://wiki.haskell.org/Diagrams/Dev/Transformations.) This is exactly what we need when transforming bounding functions, which are defined in terms of perpendicular (i.e. normal) hyperplanes.
For more general, non-invertible transformations, see
Diagrams.Deform (in diagrams-lib).
Instances
inv :: (Functor v, Num n) => Transformation v n -> Transformation v n Source #
Invert a transformation.
transp :: Transformation v n -> v n :-: v n Source #
Get the transpose of a transformation (ignoring the translation component).
transl :: Transformation v n -> v n Source #
Get the translational component of a transformation.
dropTransl :: (Additive v, Num n) => Transformation v n -> Transformation v n Source #
Drop the translational component of a transformation, leaving only the linear part.
apply :: Transformation v n -> v n -> v n Source #
Apply a transformation to a vector. Note that any translational component of the transformation will not affect the vector, since vectors are invariant under translation.
papply :: (Additive v, Num n) => Transformation v n -> Point v n -> Point v n Source #
Apply a transformation to a point.
fromLinear :: (Additive v, Num n) => (v n :-: v n) -> (v n :-: v n) -> Transformation v n Source #
Create a general affine transformation from an invertible linear transformation and its transpose. The translational component is assumed to be zero.
Some specific transformations
translation :: v n -> Transformation v n Source #
Create a translation.
translate :: Transformable t => Vn t -> t -> t Source #
Translate by a vector.
moveTo :: (InSpace v n t, HasOrigin t) => Point v n -> t -> t Source #
Translate the object by the translation that sends the origin to
the given point. Note that this is dual to moveOriginTo, i.e. we
should have
moveTo (origin .^+ v) === moveOriginTo (origin .^- v)
For types which are also Transformable, this is essentially the
same as translate, i.e.
moveTo (origin .^+ v) === translate v
place :: (InSpace v n t, HasOrigin t) => t -> Point v n -> t Source #
A flipped variant of moveTo, provided for convenience. Useful
when writing a function which takes a point as an argument, such
as when using withName and friends.
scaling :: (Additive v, Fractional n) => n -> Transformation v n Source #
Create a uniform scaling transformation.
scale :: (InSpace v n a, Eq n, Fractional n, Transformable a) => n -> a -> a Source #
Scale uniformly in every dimension by the given scalar.
avgScale :: (Additive v, Traversable v, Floating n) => Transformation v n -> n Source #
Compute the "average" amount of scaling performed by a transformation. Satisfies the properties
avgScale (scaling k) == k avgScale (t1 <> t2) == avgScale t1 * avgScale t2
The Transformable class
class Transformable t where Source #
Type class for things t which can be transformed.
Methods
transform :: Transformation (V t) (N t) -> t -> t Source #
Apply a transformation to an object.
Instances
Translational invariance
TransInv is a wrapper which makes a transformable type
translationally invariant; the translational component of
transformations will no longer affect things wrapped in
TransInv.
Constructors
| TransInv t |
Instances
| Monoid t => Monoid (TransInv t) Source # | |
| Semigroup t => Semigroup (TransInv t) Source # | |
| Show t => Show (TransInv t) Source # | |
| Enveloped t => Enveloped (TransInv t) Source # | |
Defined in Diagrams.Core.Envelope | |
| HasOrigin (TransInv t) Source # | |
| Qualifiable a => Qualifiable (TransInv a) Source # | |
| Traced t => Traced (TransInv t) Source # | |
| (Num (N t), Additive (V t), Transformable t) => Transformable (TransInv t) Source # | |
| Eq t => Eq (TransInv t) Source # | |
| Ord t => Ord (TransInv t) Source # | |
Defined in Diagrams.Core.Transform | |
| Wrapped (TransInv t) Source # | |
| Rewrapped (TransInv t) (TransInv t') Source # | |
Defined in Diagrams.Core.Transform | |
| type N (TransInv t) Source # | |
Defined in Diagrams.Core.Transform | |
| type V (TransInv t) Source # | |
Defined in Diagrams.Core.Transform | |
| type Unwrapped (TransInv t) Source # | |
Defined in Diagrams.Core.Transform | |
Names
A (qualified) name is a (possibly empty) sequence of atomic names.
Instances
| Monoid Name Source # | |
| Semigroup Name Source # | |
| Show Name Source # | |
| IsName Name Source # | |
| Qualifiable Name Source # | Of course, names can be qualified using |
| Eq Name Source # | |
| Ord Name Source # | |
| Wrapped Name Source # | |
| Rewrapped Name Name Source # | |
Defined in Diagrams.Core.Names | |
| Each Name Name AName AName Source # | |
| Action Name a => Action Name (Deletable a) Source # | |
| Action Name (Envelope v n) Source # | |
| Action Name (Trace v n) Source # | |
| Action Name (Query v n m) Source # | |
| Action Name (SubMap b v n m) Source # | A name acts on a name map by qualifying every name in it. |
| type Unwrapped Name Source # | |
Defined in Diagrams.Core.Names | |
class (Typeable a, Ord a, Show a) => IsName a where Source #
Class for those types which can be used as names. They must
support Typeable (to facilitate extracting them from
existential wrappers), Ord (for comparison and efficient
storage) and Show.
To make an instance of IsName, you need not define any methods,
just declare it.
WARNING: it is not recommended to use
GeneralizedNewtypeDeriving in conjunction with IsName, since
in that case the underlying type and the newtype will be
considered equivalent when comparing names. For example:
newtype WordN = WordN Int deriving (Show, Ord, Eq, Typeable, IsName)
is unlikely to work as intended, since (1 :: Int) and (WordN 1)
will be considered equal as names. Instead, use
newtype WordN = WordN Int deriving (Show, Ord, Eq, Typeable, IsName)
instance IsName WordN
Minimal complete definition
Nothing
Instances
| IsName AName Source # | |
| IsName Name Source # | |
| IsName Integer Source # | |
| IsName () Source # | |
Defined in Diagrams.Core.Names | |
| IsName Bool Source # | |
| IsName Char Source # | |
| IsName Double Source # | |
| IsName Float Source # | |
| IsName Int Source # | |
| IsName a => IsName (Maybe a) Source # | |
| IsName a => IsName [a] Source # | |
Defined in Diagrams.Core.Names | |
| (IsName a, IsName b) => IsName (a, b) Source # | |
Defined in Diagrams.Core.Names | |
| (IsName a, IsName b, IsName c) => IsName (a, b, c) Source # | |
Defined in Diagrams.Core.Names | |
class Qualifiable q where Source #
Instances of Qualifiable are things which can be qualified by
prefixing them with a name.
Instances
| Qualifiable Name Source # | Of course, names can be qualified using |
| (Ord a, Qualifiable a) => Qualifiable (Set a) Source # | |
| Qualifiable a => Qualifiable (TransInv a) Source # | |
| Qualifiable a => Qualifiable [a] Source # | |
Defined in Diagrams.Core.Names | |
| Qualifiable a => Qualifiable (Map k a) Source # | |
| Qualifiable a => Qualifiable (Measured n a) Source # | |
| Qualifiable a => Qualifiable (b -> a) Source # | |
Defined in Diagrams.Core.Names | |
| (Qualifiable a, Qualifiable b) => Qualifiable (a, b) Source # | |
Defined in Diagrams.Core.Names | |
| (Qualifiable a, Qualifiable b, Qualifiable c) => Qualifiable (a, b, c) Source # | |
Defined in Diagrams.Core.Names | |
| (Metric v, OrderedField n, Semigroup m) => Qualifiable (QDiagram b v n m) Source # | Diagrams can be qualified so that all their named points can now be referred to using the qualification prefix. |
| Qualifiable (SubMap b v n m) Source # |
|
(.>) :: (IsName a1, IsName a2) => a1 -> a2 -> Name infixr 5 Source #
Convenient operator for writing qualified names with atomic
components of different types. Instead of writing toName a1 <>
toName a2 <> toName a3 you can just write a1 .> a2 .> a3.
eachName :: (Typeable a, Ord a, Show a) => Traversal' Name a Source #
Traversal over each name in a Name that matches the target type.
>>> toListOf eachName (a.> False .>b) :: String "ab" >>>a.> True .>b& eachName %~ nota.> False .>b
Note that the type of the name is very important.
>>> sumOf eachName ((1::Int) .> (2 :: Integer) .> (3 :: Int)) :: Int 4 >>> sumOf eachName ((1::Int) .> (2 :: Integer) .> (3 :: Int)) :: Integer 2
Subdiagram maps
newtype SubMap b v n m Source #
A SubMap is a map associating names to subdiagrams. There can
be multiple associations for any given name.
Constructors
| SubMap (Map Name [Subdiagram b v n m]) |
Instances
| Action Name (SubMap b v n m) Source # | A name acts on a name map by qualifying every name in it. |
| Functor (SubMap b v n) Source # | |
| Monoid (SubMap b v n m) Source # |
|
| Semigroup (SubMap b v n m) Source # | |
| (OrderedField n, Metric v) => HasOrigin (SubMap b v n m) Source # | |
| Qualifiable (SubMap b v n m) Source # |
|
| Transformable (SubMap b v n m) Source # | |
| Wrapped (SubMap b v n m) Source # | |
| Rewrapped (SubMap b v n m) (SubMap b' v' n' m') Source # | |
Defined in Diagrams.Core.Types | |
| type N (SubMap b v n m) Source # | |
Defined in Diagrams.Core.Types | |
| type V (SubMap b v n m) Source # | |
Defined in Diagrams.Core.Types | |
| type Unwrapped (SubMap b v n m) Source # | |
Defined in Diagrams.Core.Types | |
fromNames :: IsName a => [(a, Subdiagram b v n m)] -> SubMap b v n m Source #
Construct a SubMap from a list of associations between names
and subdiagrams.
rememberAs :: IsName a => a -> QDiagram b v n m -> SubMap b v n m -> SubMap b v n m Source #
Add a name/diagram association to a submap.
lookupSub :: IsName nm => nm -> SubMap b v n m -> Maybe [Subdiagram b v n m] Source #
Look for the given name in a name map, returning a list of subdiagrams associated with that name. If no names match the given name exactly, return all the subdiagrams associated with names of which the given name is a suffix.
Attributes and styles
class (Typeable a, Semigroup a) => AttributeClass a Source #
data Attribute (v :: Type -> Type) n :: Type where Source #
An existential wrapper type to hold attributes. Some attributes are simply inert/static; some are affected by transformations; and some are affected by transformations and can be modified generically.
Constructors
| Attribute :: AttributeClass a => a -> Attribute v n | |
| MAttribute :: AttributeClass a => Measured n a -> Attribute v n | |
| TAttribute :: (AttributeClass a, Transformable a, V a ~ v, N a ~ n) => a -> Attribute v n |
Instances
| Typeable n => Semigroup (Attribute v n) Source # | Attributes form a semigroup, where the semigroup operation simply returns the right-hand attribute when the types do not match, and otherwise uses the semigroup operation specific to the (matching) types. |
| Show (Attribute v n) Source # | Shows the kind of attribute and the type contained in the attribute. |
| (Additive v, Traversable v, Floating n) => Transformable (Attribute v n) Source # |
|
| Each (Style v n) (Style v' n') (Attribute v n) (Attribute v' n') Source # | |
| type N (Attribute v n) Source # | |
Defined in Diagrams.Core.Style | |
| type V (Attribute v n) Source # | |
Defined in Diagrams.Core.Style | |
A Style is a heterogeneous collection of attributes, containing
at most one attribute of any given type.
Instances
| Typeable n => Monoid (Style v n) Source # | The empty style contains no attributes. |
| Typeable n => Semigroup (Style v n) Source # | Combine a style by combining the attributes; if the two styles have attributes of the same type they are combined according to their semigroup structure. |
| Show (Style v n) Source # | Show the attributes in the style. |
| Typeable n => HasStyle (Style v n) Source # | |
| (Additive v, Traversable v, Floating n) => Transformable (Style v n) Source # | |
| At (Style v n) Source # | |
| Ixed (Style v n) Source # | |
Defined in Diagrams.Core.Style | |
| Wrapped (Style v n) Source # | |
| Action (Style v n) m Source # | Styles have no action on other monoids. |
Defined in Diagrams.Core.Style | |
| Rewrapped (Style v n) (Style v' n') Source # | |
Defined in Diagrams.Core.Style | |
| Each (Style v n) (Style v' n') (Attribute v n) (Attribute v' n') Source # | |
| type N (Style v n) Source # | |
Defined in Diagrams.Core.Style | |
| type V (Style v n) Source # | |
Defined in Diagrams.Core.Style | |
| type Index (Style v n) Source # | |
Defined in Diagrams.Core.Style | |
| type IxValue (Style v n) Source # | |
Defined in Diagrams.Core.Style | |
| type Unwrapped (Style v n) Source # | |
class HasStyle a where Source #
Type class for things which have a style.
Methods
applyStyle :: Style (V a) (N a) -> a -> a Source #
Apply a style by combining it (on the left) with the existing style.
Instances
| (HasStyle a, Ord a) => HasStyle (Set a) Source # | |
| HasStyle a => HasStyle [a] Source # | |
Defined in Diagrams.Core.Style | |
| HasStyle a => HasStyle (Map k a) Source # | |
| HasStyle b => HasStyle (Measured n b) Source # | |
| Typeable n => HasStyle (Style v n) Source # | |
| HasStyle b => HasStyle (a -> b) Source # | |
Defined in Diagrams.Core.Style | |
| (HasStyle a, HasStyle b, V a ~ V b, N a ~ N b) => HasStyle (a, b) Source # | |
Defined in Diagrams.Core.Style | |
| (Metric v, OrderedField n, Semigroup m) => HasStyle (QDiagram b v n m) Source # | |
getAttr :: forall a v n. AttributeClass a => Style v n -> Maybe a Source #
Extract an attribute from a style of a particular type. If the
style contains an attribute of the requested type, it will be
returned wrapped in Just; otherwise, Nothing is returned.
Trying to extract a measured attibute will fail. It either has to
be unmeasured with unmeasureAttrs or use the atMAttr lens.
atAttr :: AttributeClass a => Lens' (Style v n) (Maybe a) Source #
Lens onto a plain attribute of a style.
atMAttr :: (AttributeClass a, Typeable n) => Lens' (Style v n) (Maybe (Measured n a)) Source #
Lens onto a measured attribute of a style.
atTAttr :: (V a ~ v, N a ~ n, AttributeClass a, Transformable a) => Lens' (Style v n) (Maybe a) Source #
Lens onto a transformable attribute of a style.
applyAttr :: (AttributeClass a, HasStyle d) => a -> d -> d Source #
Apply an attribute to an instance of HasStyle (such as a
diagram or a style). If the object already has an attribute of
the same type, the new attribute is combined on the left with the
existing attribute, according to their semigroup structure.
applyMAttr :: (AttributeClass a, N d ~ n, HasStyle d) => Measured n a -> d -> d Source #
Apply a measured attribute to an instance of HasStyle (such as a
diagram or a style). If the object already has an attribute of
the same type, the new attribute is combined on the left with the
existing attribute, according to their semigroup structure.
applyTAttr :: (AttributeClass a, Transformable a, V a ~ V d, N a ~ N d, HasStyle d) => a -> d -> d Source #
Apply a transformable attribute to an instance of HasStyle
(such as a diagram or a style). If the object already has an
attribute of the same type, the new attribute is combined on the
left with the existing attribute, according to their semigroup
structure.
Envelopes
Every diagram comes equipped with an envelope. What is an envelope?
Consider first the idea of a bounding box. A bounding box expresses the distance to a bounding plane in every direction parallel to an axis. That is, a bounding box can be thought of as the intersection of a collection of half-planes, two perpendicular to each axis.
More generally, the intersection of half-planes in every direction would give a tight "bounding region", or convex hull. However, representing such a thing intensionally would be impossible; hence bounding boxes are often used as an approximation.
An envelope is an extensional representation of such a "bounding region". Instead of storing some sort of direct representation, we store a function which takes a direction as input and gives a distance to a bounding half-plane as output. The important point is that envelopes can be composed, and transformed by any affine transformation.
Formally, given a vector v, the envelope computes a scalar s such
that
- for every point
uinside the diagram, if the projection of(u - origin)ontoviss' *^ v, thens' <= s. sis the smallest such scalar.
There is also a special "empty envelope".
The idea for envelopes came from Sebastian Setzer; see http://byorgey.wordpress.com/2009/10/28/collecting-attributes/#comment-2030. See also Brent Yorgey, Monoids: Theme and Variations, published in the 2012 Haskell Symposium: http://ozark.hendrix.edu/~yorgey/pub/monoid-pearl.pdf; video: http://www.youtube.com/watch?v=X-8NCkD2vOw.
Instances
| Action Name (Envelope v n) Source # | |
| Ord n => Monoid (Envelope v n) Source # | The special empty envelope is the identity for the
|
| Ord n => Semigroup (Envelope v n) Source # | Envelopes form a semigroup with pointwise maximum as composition.
Hence, if |
| Show (Envelope v n) Source # | |
| (Metric v, OrderedField n) => Enveloped (Envelope v n) Source # | |
Defined in Diagrams.Core.Envelope | |
| (Metric v, Fractional n) => HasOrigin (Envelope v n) Source # | The local origin of an envelope is the point with respect to which bounding queries are made, i.e. the point from which the input vectors are taken to originate. |
| (Metric v, OrderedField n) => Juxtaposable (Envelope v n) Source # | |
| (Metric v, Floating n) => Transformable (Envelope v n) Source # | |
| Wrapped (Envelope v n) Source # | |
| Rewrapped (Envelope v n) (Envelope v' n') Source # | |
Defined in Diagrams.Core.Envelope | |
| type N (Envelope v n) Source # | |
Defined in Diagrams.Core.Envelope | |
| type V (Envelope v n) Source # | |
Defined in Diagrams.Core.Envelope | |
| type Unwrapped (Envelope v n) Source # | |
Defined in Diagrams.Core.Envelope | |
appEnvelope :: Envelope v n -> Maybe (v n -> n) Source #
"Apply" an envelope by turning it into a function. Nothing
is returned iff the envelope is empty.
onEnvelope :: ((v n -> n) -> v n -> n) -> Envelope v n -> Envelope v n Source #
A convenient way to transform an envelope, by specifying a
transformation on the underlying v n -> n function. The empty
envelope is unaffected.
mkEnvelope :: (v n -> n) -> Envelope v n Source #
Create an envelope from a v n -> n function.
class (Metric (V a), OrderedField (N a)) => Enveloped a where Source #
Enveloped abstracts over things which have an envelope.
Methods
getEnvelope :: a -> Envelope (V a) (N a) Source #
Compute the envelope of an object. For types with an intrinsic
notion of "local origin", the envelope will be based there.
Other types (e.g. Trail) may have some other default
reference point at which the envelope will be based; their
instances should document what it is.
Instances
| Enveloped b => Enveloped (Set b) Source # | |
Defined in Diagrams.Core.Envelope | |
| Enveloped t => Enveloped (TransInv t) Source # | |
Defined in Diagrams.Core.Envelope | |
| Enveloped b => Enveloped [b] Source # | |
Defined in Diagrams.Core.Envelope | |
| Enveloped b => Enveloped (Map k b) Source # | |
Defined in Diagrams.Core.Envelope | |
| (Metric v, OrderedField n) => Enveloped (Envelope v n) Source # | |
Defined in Diagrams.Core.Envelope | |
| (OrderedField n, Metric v) => Enveloped (Point v n) Source # | |
Defined in Diagrams.Core.Envelope | |
| (Enveloped a, Enveloped b, V a ~ V b, N a ~ N b) => Enveloped (a, b) Source # | |
Defined in Diagrams.Core.Envelope | |
| (Metric v, OrderedField n, Monoid' m) => Enveloped (QDiagram b v n m) Source # | |
Defined in Diagrams.Core.Types | |
| (OrderedField n, Metric v, Monoid' m) => Enveloped (Subdiagram b v n m) Source # | |
Defined in Diagrams.Core.Types Methods getEnvelope :: Subdiagram b v n m -> Envelope (V (Subdiagram b v n m)) (N (Subdiagram b v n m)) Source # | |
envelopeVMay :: Enveloped a => Vn a -> a -> Maybe (Vn a) Source #
Compute the vector from the local origin to a separating
hyperplane in the given direction, or Nothing for the empty
envelope.
envelopeV :: Enveloped a => Vn a -> a -> Vn a Source #
Compute the vector from the local origin to a separating hyperplane in the given direction. Returns the zero vector for the empty envelope.
envelopePMay :: (V a ~ v, N a ~ n, Enveloped a) => v n -> a -> Maybe (Point v n) Source #
Compute the point on a separating hyperplane in the given
direction, or Nothing for the empty envelope.
envelopeP :: (V a ~ v, N a ~ n, Enveloped a) => v n -> a -> Point v n Source #
Compute the point on a separating hyperplane in the given direction. Returns the origin for the empty envelope.
diameter :: (V a ~ v, N a ~ n, Enveloped a) => v n -> a -> n Source #
Compute the diameter of a enveloped object along a particular vector. Returns zero for the empty envelope.
radius :: (V a ~ v, N a ~ n, Enveloped a) => v n -> a -> n Source #
Compute the "radius" (1/2 the diameter) of an enveloped object along a particular vector.
size :: (V a ~ v, N a ~ n, Enveloped a, HasBasis v) => a -> v n Source #
The smallest positive axis-parallel vector that bounds the envelope of an object.
Traces
Every diagram comes equipped with a trace. Intuitively, the trace for a diagram is like a raytracer: given a line (represented as a base point and a direction vector), the trace computes a sorted list of signed distances from the base point to all intersections of the line with the boundary of the diagram.
Note that the outputs are not absolute distances, but multipliers
relative to the input vector. That is, if the base point is p
and direction vector is v, and one of the output scalars is
s, then there is an intersection at the point p .+^ (s *^ v).
Constructors
| Trace (Point v n -> v n -> SortedList n) |
Instances
| Action Name (Trace v n) Source # | |
| Ord n => Monoid (Trace v n) Source # | |
| Ord n => Semigroup (Trace v n) Source # | Traces form a semigroup with pointwise minimum as composition.
Hence, if |
| Show (Trace v n) Source # | |
| (Additive v, Num n) => HasOrigin (Trace v n) Source # | |
| (Additive v, Ord n) => Traced (Trace v n) Source # | |
| (Additive v, Num n) => Transformable (Trace v n) Source # | |
| Wrapped (Trace v n) Source # | |
| Rewrapped (Trace v n) (Trace v' n') Source # | |
Defined in Diagrams.Core.Trace | |
| type N (Trace v n) Source # | |
Defined in Diagrams.Core.Trace | |
| type V (Trace v n) Source # | |
Defined in Diagrams.Core.Trace | |
| type Unwrapped (Trace v n) Source # | |
Defined in Diagrams.Core.Trace | |
data SortedList a Source #
A newtype wrapper around a list which maintains the invariant
that the list is sorted. The constructor is not exported; use
the smart constructor mkSortedList (which sorts the given list)
instead.
Instances
| Ord a => Monoid (SortedList a) Source # |
|
Defined in Diagrams.Core.Trace Methods mempty :: SortedList a # mappend :: SortedList a -> SortedList a -> SortedList a # mconcat :: [SortedList a] -> SortedList a # | |
| Ord a => Semigroup (SortedList a) Source # |
|
Defined in Diagrams.Core.Trace Methods (<>) :: SortedList a -> SortedList a -> SortedList a # sconcat :: NonEmpty (SortedList a) -> SortedList a # stimes :: Integral b => b -> SortedList a -> SortedList a # | |
mkSortedList :: Ord a => [a] -> SortedList a Source #
A smart constructor for the SortedList type, which sorts the
input to ensure the SortedList invariant.
getSortedList :: SortedList a -> [a] Source #
Project the (guaranteed sorted) list out of a SortedList
wrapper.
class (Additive (V a), Ord (N a)) => Traced a where Source #
Traced abstracts over things which have a trace.
Instances
| Traced b => Traced (Set b) Source # | |
| Traced t => Traced (TransInv t) Source # | |
| Traced b => Traced [b] Source # | |
| Traced b => Traced (Map k b) Source # | |
| (Additive v, Ord n) => Traced (Trace v n) Source # | |
| (Additive v, Ord n) => Traced (Point v n) Source # | The trace of a single point is the empty trace, i.e. the one which returns no intersection points for every query. Arguably it should return a single finite distance for vectors aimed directly at the given point, but due to floating-point inaccuracy this is problematic. Note that the envelope for a single point is not the empty envelope (see Diagrams.Core.Envelope). |
| (Traced a, Traced b, SameSpace a b) => Traced (a, b) Source # | |
| (Metric v, OrderedField n, Semigroup m) => Traced (QDiagram b v n m) Source # | |
| (OrderedField n, Metric v, Semigroup m) => Traced (Subdiagram b v n m) Source # | |
Defined in Diagrams.Core.Types Methods getTrace :: Subdiagram b v n m -> Trace (V (Subdiagram b v n m)) (N (Subdiagram b v n m)) Source # | |
traceV :: (n ~ N a, Num n, Traced a) => Point (V a) n -> V a n -> a -> Maybe (V a n) Source #
Compute the vector from the given point p to the "smallest"
boundary intersection along the given vector v. The
"smallest" boundary intersection is defined as the one given by
p .+^ (s *^ v) for the smallest (most negative) value of
s. Return Nothing if there is no intersection. See also
traceP.
See also rayTraceV which uses the smallest positive
intersection, which is often more intuitive behavior.
traceP :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (Point (V a) n) Source #
Compute the "smallest" boundary point along the line determined
by the given point p and vector v. The "smallest" boundary
point is defined as the one given by p .+^ (s *^ v) for
the smallest (most negative) value of s. Return Nothing if
there is no such boundary point. See also traceV.
See also rayTraceP which uses the smallest positive
intersection, which is often more intuitive behavior.
maxTraceV :: (n ~ N a, Num n, Traced a) => Point (V a) n -> V a n -> a -> Maybe (V a n) Source #
Like traceV, but computes a vector to the "largest" boundary
point instead of the smallest. (Note, however, the "largest"
boundary point may still be in the opposite direction from the
given vector, if all the boundary points are, as in the third
example shown below.)
maxTraceP :: (n ~ N a, Num n, Traced a) => Point (V a) n -> V a n -> a -> Maybe (Point (V a) n) Source #
Like traceP, but computes the "largest" boundary point
instead of the smallest. (Note, however, the "largest" boundary
point may still be in the opposite direction from the given
vector, if all the boundary points are.)
rayTraceV :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (V a n) Source #
Compute the vector from the given point to the closest boundary
point of the given object in the given direction, or Nothing if
there is no such boundary point (as in the third example
below). Note that unlike traceV, only positive boundary
points are considered, i.e. boundary points corresponding to a
positive scalar multiple of the direction vector. This is
intuitively the "usual" behavior of a raytracer, which only
considers intersections "in front of" the camera. Compare the
second example diagram below with the second example shown for
traceV.
rayTraceP :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (Point (V a) n) Source #
Compute the boundary point on an object which is closest to the
given base point in the given direction, or Nothing if there is
no such boundary point. Note that unlike traceP, only positive
boundary points are considered, i.e. boundary points
corresponding to a positive scalar multiple of the direction
vector. This is intuitively the "usual" behavior of a raytracer,
which only considers intersection points "in front of" the
camera.
maxRayTraceV :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (V a n) Source #
Like rayTraceV, but computes a vector to the "largest"
boundary point instead of the smallest. Considers only
positive boundary points.
maxRayTraceP :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (Point (V a) n) Source #
Like rayTraceP, but computes the "largest" boundary point
instead of the smallest. Considers only positive boundary
points.
Things with local origins
class HasOrigin t where Source #
Class of types which have an intrinsic notion of a "local origin", i.e. things which are not invariant under translation, and which allow the origin to be moved.
One might wonder why not just use Transformable instead of
having a separate class for HasOrigin; indeed, for types which
are instances of both we should have the identity
moveOriginTo (origin .^+ v) === translate (negated v)
The reason is that some things (e.g. vectors, Trails) are
transformable but are translationally invariant, i.e. have no
origin.
Methods
moveOriginTo :: Point (V t) (N t) -> t -> t Source #
Move the local origin to another point.
Note that this function is in some sense dual to translate
(for types which are also Transformable); moving the origin
itself while leaving the object "fixed" is dual to fixing the
origin and translating the diagram.
Instances
moveOriginBy :: (V t ~ v, N t ~ n, HasOrigin t) => v n -> t -> t Source #
Move the local origin by a relative vector.
Juxtaposable things
class Juxtaposable a where Source #
Class of things which can be placed "next to" other things, for some appropriate notion of "next to".
Methods
juxtapose :: Vn a -> a -> a -> a Source #
juxtapose v a1 a2 positions a2 next to a1 in the
direction of v. In particular, place a2 so that v points
from the local origin of a1 towards the old local origin of
a2; a1's local origin becomes a2's new local origin. The
result is just a translated version of a2. (In particular,
this operation does not combine a1 and a2 in any way.)
Instances
| (Enveloped b, HasOrigin b, Ord b) => Juxtaposable (Set b) Source # | |
| (Enveloped b, HasOrigin b) => Juxtaposable [b] Source # | |
Defined in Diagrams.Core.Juxtapose | |
| (Enveloped b, HasOrigin b) => Juxtaposable (Map k b) Source # | |
| (Metric v, OrderedField n) => Juxtaposable (Envelope v n) Source # | |
| Juxtaposable a => Juxtaposable (Measured n a) Source # | |
| Juxtaposable a => Juxtaposable (b -> a) Source # | |
Defined in Diagrams.Core.Juxtapose | |
| (Enveloped a, HasOrigin a, Enveloped b, HasOrigin b, V a ~ V b, N a ~ N b) => Juxtaposable (a, b) Source # | |
Defined in Diagrams.Core.Juxtapose | |
| (Metric v, OrderedField n, Monoid' m) => Juxtaposable (QDiagram b v n m) Source # | |
Queries
A query is a function that maps points in a vector space to values in some monoid. Queries naturally form a monoid, with two queries being combined pointwise.
The idea for annotating diagrams with monoidal queries came from the graphics-drawingcombinators package, http://hackage.haskell.org/package/graphics-drawingcombinators.
Instances
Primitives
data Prim b v n where Source #
A value of type Prim b v n is an opaque (existentially quantified)
primitive which backend b knows how to render in vector space v.
Constructors
| Prim :: (Transformable p, Typeable p, Renderable p b) => p -> Prim b (V p) (N p) |
Instances
| Transformable (Prim b v n) Source # | The |
| Renderable (Prim b v n) b Source # | The |
| type N (Prim b v n) Source # | |
Defined in Diagrams.Core.Types | |
| type V (Prim b v n) Source # | |
Defined in Diagrams.Core.Types | |
Diagrams
data QDiagram b v n m Source #
The fundamental diagram type. The type variables are as follows:
brepresents the backend, such asSVGorCairo. Note that each backend also exports a type synonymBfor itself, so the type variablebmay also typically be instantiated byB, meaning "use whatever backend is in scope".vrepresents the vector space of the diagram. Typical instantiations includeV2(for a two-dimensional diagram) orV3(for a three-dimensional diagram).nrepresents the numerical field the diagram uses. Typically this will be a concrete numeric type likeDouble.mis the monoidal type of "query annotations": each point in the diagram has a value of typemassociated to it, and these values are combined according to theMonoidinstance form. Most often,mis simply instantiated toAny, associating a simpleBoolvalue to each point indicating whether the point is inside the diagram;Diagramis a synonym forQDiagramwithmthus instantiated toAny.
Diagrams can be combined via their Monoid instance, transformed
via their Transformable instance, and assigned attributes via
their HasStyle instance.
Note that the Q in QDiagram stands for "Queriable", as
distinguished from Diagram, where m is fixed to Any. This
is not really a very good name, but it's probably not worth
changing it at this point.
Instances
| Functor (QDiagram b v n) Source # | |
| (Metric v, OrderedField n, Semigroup m) => Monoid (QDiagram b v n m) Source # | Diagrams form a monoid since each of their components do: the empty diagram has no primitives, an empty envelope, an empty trace, no named subdiagrams, and a constantly empty query function. Diagrams compose by aligning their respective local origins. The new diagram has all the primitives and all the names from the two diagrams combined, and query functions are combined pointwise. The first diagram goes on top of the second. "On top of" probably only makes sense in vector spaces of dimension lower than 3, but in theory it could make sense for, say, 3-dimensional diagrams when viewed by 4-dimensional beings. |
| (Metric v, OrderedField n, Semigroup m) => Semigroup (QDiagram b v n m) Source # | |
| (Metric v, OrderedField n, Monoid' m) => Enveloped (QDiagram b v n m) Source # | |
Defined in Diagrams.Core.Types | |
| (Metric v, OrderedField n, Semigroup m) => HasOrigin (QDiagram b v n m) Source # | Every diagram has an intrinsic "local origin" which is the basis for all combining operations. |
| (Metric v, OrderedField n, Monoid' m) => Juxtaposable (QDiagram b v n m) Source # | |
| (Metric v, OrderedField n, Semigroup m) => Qualifiable (QDiagram b v n m) Source # | Diagrams can be qualified so that all their named points can now be referred to using the qualification prefix. |
| (Metric v, OrderedField n, Semigroup m) => HasStyle (QDiagram b v n m) Source # | |
| (Metric v, OrderedField n, Semigroup m) => Traced (QDiagram b v n m) Source # | |
| (OrderedField n, Metric v, Semigroup m) => Transformable (QDiagram b v n m) Source # | Diagrams can be transformed by transforming each of their components appropriately. |
| Wrapped (QDiagram b v n m) Source # | |
| Rewrapped (QDiagram b v n m) (QDiagram b' v' n' m') Source # | |
Defined in Diagrams.Core.Types | |
| type N (QDiagram b v n m) Source # | |
Defined in Diagrams.Core.Types | |
| type V (QDiagram b v n m) Source # | |
Defined in Diagrams.Core.Types | |
| type Unwrapped (QDiagram b v n m) Source # | |
Defined in Diagrams.Core.Types type Unwrapped (QDiagram b v n m) = DUALTree (DownAnnots v n) (UpAnnots b v n m) Annotation (QDiaLeaf b v n m) | |
type Diagram b = QDiagram b (V b) (N b) Any Source #
Diagram b is a synonym for QDiagram b (V b) (N b) AnyFunctor instance of QDiagram b v nvalue function.
mkQD :: Prim b v n -> Envelope v n -> Trace v n -> SubMap b v n m -> Query v n m -> QDiagram b v n m Source #
Create a diagram from a single primitive, along with an envelope, trace, subdiagram map, and query function.
pointDiagram :: (Metric v, Fractional n) => Point v n -> QDiagram b v n m Source #
Create a "point diagram", which has no content, no trace, an empty query, and a point envelope.
envelope :: (OrderedField n, Metric v, Monoid' m) => Lens' (QDiagram b v n m) (Envelope v n) Source #
subMap :: (Metric v, Semigroup m, OrderedField n) => Lens' (QDiagram b v n m) (SubMap b v n m) Source #
names :: (Metric v, Semigroup m, OrderedField n) => QDiagram b v n m -> [(Name, [Point v n])] Source #
Get a list of names of subdiagrams and their locations.
query :: Monoid m => QDiagram b v n m -> Query v n m Source #
Get the query function associated with a diagram.
nameSub :: (IsName nm, Metric v, OrderedField n, Semigroup m) => (QDiagram b v n m -> Subdiagram b v n m) -> nm -> QDiagram b v n m -> QDiagram b v n m Source #
Attach an atomic name to a certain subdiagram, computed from the
given diagram /with the mapping from name to subdiagram
included/. The upshot of this knot-tying is that if d' = d #
named x, then lookupName x d' == Just d' (instead of Just
d).
withName :: (IsName nm, Metric v, Semigroup m, OrderedField n) => nm -> (Subdiagram b v n m -> QDiagram b v n m -> QDiagram b v n m) -> QDiagram b v n m -> QDiagram b v n m Source #
Given a name and a diagram transformation indexed by a subdiagram, perform the transformation using the most recent subdiagram associated with (some qualification of) the name, or perform the identity transformation if the name does not exist.
withNameAll :: (IsName nm, Metric v, Semigroup m, OrderedField n) => nm -> ([Subdiagram b v n m] -> QDiagram b v n m -> QDiagram b v n m) -> QDiagram b v n m -> QDiagram b v n m Source #
Given a name and a diagram transformation indexed by a list of subdiagrams, perform the transformation using the collection of all such subdiagrams associated with (some qualification of) the given name.
withNames :: (IsName nm, Metric v, Semigroup m, OrderedField n) => [nm] -> ([Subdiagram b v n m] -> QDiagram b v n m -> QDiagram b v n m) -> QDiagram b v n m -> QDiagram b v n m Source #
Given a list of names and a diagram transformation indexed by a list of subdiagrams, perform the transformation using the list of most recent subdiagrams associated with (some qualification of) each name. Do nothing (the identity transformation) if any of the names do not exist.
localize :: forall b v n m. (Metric v, OrderedField n, Semigroup m) => QDiagram b v n m -> QDiagram b v n m Source #
"Localize" a diagram by hiding all the names, so they are no longer visible to the outside.
href :: (Metric v, OrderedField n, Semigroup m) => String -> QDiagram b v n m -> QDiagram b v n m Source #
Make a diagram into a hyperlink. Note that only some backends will honor hyperlink annotations.
opacityGroup :: (Metric v, OrderedField n, Semigroup m) => Double -> QDiagram b v n m -> QDiagram b v n m Source #
Change the transparency of a Diagram as a group.
groupOpacity :: (Metric v, OrderedField n, Semigroup m) => Double -> QDiagram b v n m -> QDiagram b v n m Source #
Change the transparency of a Diagram as a group.
setEnvelope :: forall b v n m. (OrderedField n, Metric v, Monoid' m) => Envelope v n -> QDiagram b v n m -> QDiagram b v n m Source #
Replace the envelope of a diagram.
setTrace :: forall b v n m. (OrderedField n, Metric v, Semigroup m) => Trace v n -> QDiagram b v n m -> QDiagram b v n m Source #
Replace the trace of a diagram.
atop :: (OrderedField n, Metric v, Semigroup m) => QDiagram b v n m -> QDiagram b v n m -> QDiagram b v n m infixl 6 Source #
A convenient synonym for mappend on diagrams, designed to be
used infix (to help remember which diagram goes on top of which
when combining them, namely, the first on top of the second).
Subdiagrams
data Subdiagram b v n m Source #
A Subdiagram represents a diagram embedded within the context
of a larger diagram. Essentially, it consists of a diagram
paired with any accumulated information from the larger context
(transformations, attributes, etc.).
Constructors
| Subdiagram (QDiagram b v n m) (DownAnnots v n) |
Instances
mkSubdiagram :: QDiagram b v n m -> Subdiagram b v n m Source #
Turn a diagram into a subdiagram with no accumulated context.
getSub :: (Metric v, OrderedField n, Semigroup m) => Subdiagram b v n m -> QDiagram b v n m Source #
Turn a subdiagram into a normal diagram, including the enclosing
context. Concretely, a subdiagram is a pair of (1) a diagram and
(2) a "context" consisting of an extra transformation and
attributes. getSub simply applies the transformation and
attributes to the diagram to get the corresponding "top-level"
diagram.
rawSub :: Subdiagram b v n m -> QDiagram b v n m Source #
Extract the "raw" content of a subdiagram, by throwing away the context.
location :: (Additive v, Num n) => Subdiagram b v n m -> Point v n Source #
Get the location of a subdiagram; that is, the location of its local origin with respect to the vector space of its parent diagram. In other words, the point where its local origin "ended up".
subPoint :: (Metric v, OrderedField n) => Point v n -> Subdiagram b v n m Source #
Create a "point subdiagram", that is, a pointDiagram (with no
content and a point envelope) treated as a subdiagram with local
origin at the given point. Note this is not the same as
mkSubdiagram . pointDiagram, which would result in a subdiagram
with local origin at the parent origin, rather than at the given
point.
Measurements
'Measured n a' is an object that depends on local, normalized
and global scales. The normalized and global scales are
calculated when rendering a diagram.
For attributes, the local scale gets multiplied by the average
scale of the transform.
Instances
fromMeasured :: Num n => n -> n -> Measured n a -> a Source #
fromMeasured globalScale normalizedScale measure -> a
local :: Num n => n -> Measure n Source #
Local units are scaled by the average scale of a transform.
global :: Num n => n -> Measure n Source #
Global units are scaled so that they are interpreted relative to the size of the final rendered diagram.
normalized :: Num n => n -> Measure n Source #
Normalized units get scaled so that one normalized unit is the size of the final diagram.
scaleLocal :: Num n => n -> Measured n a -> Measured n a Source #
Scale the local units of a Measured thing.
atLeast :: Ord n => Measure n -> Measure n -> Measure n Source #
Calculate the larger of two measures.
atMost :: Ord n => Measure n -> Measure n -> Measure n Source #
Calculate the smaller of two measures.
Backends
class Backend b v n where Source #
Abstract diagrams are rendered to particular formats by
backends. Each backend/vector space combination must be an
instance of the Backend class.
A minimal complete definition consists of Render, Result,
Options, and renderRTree. However, most backends will want to
implement adjustDia as well; the default definition does
nothing. Some useful standard definitions are provided in the
Diagrams.TwoD.Adjust module from the diagrams-lib package.
Minimal complete definition
Associated Types
data Render b v n :: Type Source #
An intermediate representation used for rendering primitives.
(Typically, this will be some sort of monad, but it need not
be.) The Renderable class guarantees that a backend will be
able to convert primitives into this type; how these rendered
primitives are combined into an ultimate Result is completely
up to the backend.
type Result b v n :: Type Source #
The result of running/interpreting a rendering operation.
data Options b v n :: Type Source #
Backend-specific rendering options.
Methods
adjustDia :: (Additive v, Monoid' m, Num n) => b -> Options b v n -> QDiagram b v n m -> (Options b v n, Transformation v n, QDiagram b v n m) Source #
adjustDia allows the backend to make adjustments to the final
diagram (e.g. to adjust the size based on the options) before
rendering it. It returns a modified options record, the
transformation applied to the diagram (which can be used to
convert attributes whose value is Measure, or transform
e.g. screen coordinates back into local diagram coordinates),
and the adjusted diagram itself.
See the diagrams-lib package (particularly the
Diagrams.TwoD.Adjust module) for some useful implementations.
renderRTree :: b -> Options b v n -> RTree b v n Annotation -> Result b v n Source #
Given some options, take a representation of a diagram as a
tree and render it. The RTree has already been simplified
and has all measurements converted to Output units.
Instances
| Backend NullBackend v n Source # | |
Defined in Diagrams.Core.Types Associated Types data Render NullBackend v n Source # type Result NullBackend v n Source # data Options NullBackend v n Source # Methods adjustDia :: (Additive v, Monoid' m, Num n) => NullBackend -> Options NullBackend v n -> QDiagram NullBackend v n m -> (Options NullBackend v n, Transformation v n, QDiagram NullBackend v n m) Source # renderRTree :: NullBackend -> Options NullBackend v n -> RTree NullBackend v n Annotation -> Result NullBackend v n Source # | |
class Transformable t => Renderable t b where Source #
The Renderable type class connects backends to primitives which they know how to render.
renderDia :: (Backend b v n, HasLinearMap v, Metric v, Typeable n, OrderedField n, Monoid' m) => b -> Options b v n -> QDiagram b v n m -> Result b v n Source #
Render a diagram.
renderDiaT :: (Backend b v n, HasLinearMap v, Metric v, Typeable n, OrderedField n, Monoid' m) => b -> Options b v n -> QDiagram b v n m -> (Transformation v n, Result b v n) Source #
Render a diagram, returning also the transformation which was
used to convert the diagram from its ("global") coordinate
system into the output coordinate system. The inverse of this
transformation can be used, for example, to convert output/screen
coordinates back into diagram coordinates. See also adjustDia.
The null backend
data NullBackend Source #
A null backend which does no actual rendering. It is provided
mainly for convenience in situations where you must give a
diagram a concrete, monomorphic type, but don't actually care
which one. See D for more explanation and examples.
It is courteous, when defining a new primitive P, to make an instance
instance Renderable P NullBackend where render _ _ = mempty
This ensures that the trick with D annotations can be used for
diagrams containing your primitive.
Instances
type D v n = QDiagram NullBackend v n Any Source #
The D type is provided for convenience in situations where you
must give a diagram a concrete, monomorphic type, but don't care
which one. Such situations arise when you pass a diagram to a
function which is polymorphic in its input but monomorphic in its
output, such as width, height, phantom, or names. Such
functions compute some property of the diagram, or use it to
accomplish some other purpose, but do not result in the diagram
being rendered. If the diagram does not have a monomorphic type,
GHC complains that it cannot determine the diagram's type.
For example, here is the error we get if we try to compute the
width of an image (this example requires diagrams-lib):
ghci> width (image (uncheckedImageRef "foo.png" 200 200))
<interactive>:11:8:
No instance for (Renderable (DImage n0 External) b0)
arising from a use of image
The type variables n0, b0 are ambiguous
Possible fix: add a type signature that fixes these type variable(s)
Note: there is a potential instance available:
instance Fractional n => Renderable (DImage n a) NullBackend
-- Defined in Image
Possible fix:
add an instance declaration for
(Renderable (DImage n0 External) b0)
In the first argument of width, namely
`(image (uncheckedImageRef "foo.png" 200 200))'
In the expression:
width (image (uncheckedImageRef "foo.png" 200 200))
In an equation for it:
it = width (image (uncheckedImageRef "foo.png" 200 200))
GHC complains that there is no instance for Renderable (DImage n0
External) b0; what is really going on is that it does not have enough
information to decide what backend to use (hence the
uninstantiated n0 and b0). This is annoying because we know that the
choice of backend cannot possibly affect the width of the image
(it's 200! it's right there in the code!); but there is no way
for GHC to know that.
The solution is to annotate the call to image with the type
D V2 Double
ghci> width (image (uncheckedImageRef "foo.png" 200 200) :: D V2 Double) 200.00000000000006
(It turns out the width wasn't 200 after all...)
As another example, here is the error we get if we try to compute the width of a radius-1 circle:
ghci> width (circle 1)
<interactive>:12:1:
Couldn't match expected type V2 with actual type `V a0'
The type variable a0 is ambiguous
Possible fix: add a type signature that fixes these type variable(s)
In the expression: width (circle 1)
In an equation for it: it = width (circle 1)
There's even more ambiguity here. Whereas image always returns
a Diagram, the circle function can produce any TrailLike
type, and the width function can consume any Enveloped type,
so GHC has no idea what type to pick to go in the middle.
However, the solution is the same:
ghci> width (circle 1 :: D V2 Double) 1.9999999999999998
Convenience classes
type HasLinearMap v = (HasBasis v, Traversable v) Source #
HasLinearMap is a constraint synonym, just to
help shorten some of the ridiculously long constraint sets.
type HasBasis v = (Additive v, Representable v, Rep v ~ E v) Source #
An Additive vector space whose representation is made up of basis elements.
type OrderedField s = (Floating s, Ord s) Source #
When dealing with envelopes we often want scalars to be an ordered field (i.e. support all four arithmetic operations and be totally ordered) so we introduce this constraint as a convenient shorthand.
type TypeableFloat n = (Typeable n, RealFloat n) Source #