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.

Point is a newtype wrapper around vectors used to represent points, so we don't get them mixed up. The distinction between vectors and points is important: translations affect points, but leave vectors unchanged. Points are instances of the AffineSpace class from Data.AffineSpace.

The origin of the vector space v.

Scale a point by a scalar.

Get the matrix equivalent of the basis of the vector space v as a list of columns.

The determinant of a Transformation.

(v1 :-: v2) is a linear map paired with its inverse.

Create an invertible linear map from two functions which are assumed to be linear inverses.

Invert a linear map.

Apply a linear map to a vector.

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. 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-invertable transformations, see Diagrams.Deform (in diagrams-lib).

Invert a transformation.

Get the transpose of a transformation (ignoring the translation component).

Get the translational component of a transformation.

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.

Apply a transformation to a point.

Create a general affine transformation from an invertible linear transformation and its transpose. The translational component is assumed to be zero.

Create a translation.

Translate by a vector.

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

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.

Create a uniform scaling transformation.

Scale uniformly in every dimension by the given scalar.

Type class for things t which can be transformed.

TransInv is a wrapper which makes a transformable type translationally invariant; the translational component of transformations will no longer affect things wrapped in TransInv.

Atomic names. AName is just an existential wrapper around things which are Typeable, Ord and Show.

A (qualified) name is a (possibly empty) sequence of atomic names.

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.

Instances of Qualifiable are things which can be qualified by prefixing them with a name.

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.

A SubMap is a map associating names to subdiagrams. There can be multiple associations for any given name.

Construct a SubMap from a list of associations between names and subdiagrams.

Add a name/diagram association to a submap.

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.

Every attribute must be an instance of AttributeClass, which simply guarantees Typeable and Semigroup constraints. The Semigroup instance for an attribute determines how it will combine with other attributes of the same type.

An existential wrapper type to hold attributes. Some attributes are affected by transformations and some are not.

Wrap up an attribute.

Wrap up a transformable attribute.

Unwrap an unknown Attribute type, performing a dynamic (but safe) check on the type of the result. If the required type matches the type of the attribute, the attribute value is returned wrapped in Just; if the types do not match, Nothing is returned.

A Style is a heterogeneous collection of attributes, containing at most one attribute of any given type.

Type class for things which have a style.

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.

Add a new attribute to a style that does not already contain an attribute of this type, or combine it on the left with an existing attribute.

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.

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.

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 u inside the diagram, if the projection of (u - origin) onto v is s' *^ v, then s' <= s.
• s is 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://www.cis.upenn.edu/~byorgey/pub/monoid-pearl.pdf; video: http://www.youtube.com/watch?v=X-8NCkD2vOw.

Enveloped abstracts over things which have an envelope.

Compute the vector from the local origin to a separating hyperplane in the given direction, or Nothing for the empty envelope.

Compute the vector from the local origin to a separating hyperplane in the given direction. Returns the zero vector for the empty envelope.

Compute the point on a separating hyperplane in the given direction, or Nothing for the empty envelope.

Compute the point on a separating hyperplane in the given direction. Returns the origin for the empty envelope.

Compute the diameter of a enveloped object along a particular vector. Returns zero for the empty envelope.

Compute the "radius" (1/2 the diameter) of an enveloped object along a particular vector.

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).

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.

A smart constructor for the SortedList type, which sorts the input to ensure the SortedList invariant.

Project the (guaranteed sorted) list out of a SortedList wrapper.

Traced abstracts over things which have a trace.

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.

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.

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.)

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.)

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.

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.

Like rayTraceV, but computes a vector to the "largest" boundary point instead of the smallest. Considers only positive boundary points.

Like rayTraceP, but computes the "largest" boundary point instead of the smallest. Considers only positive boundary points.

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 (negateV v)

The reason is that some things (e.g. vectors, Trails) are transformable but are translationally invariant, i.e. have no origin.

Move the local origin by a relative vector.

Class of things which can be placed "next to" other things, for some appropriate notion of "next to".

Default implementation of juxtapose for things which are instances of Enveloped and HasOrigin. If either envelope is empty, the second object is returned unchanged.

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.

A value of type Prim b v is an opaque (existentially quantified) primitive which backend b knows how to render in vector space v.

A type class for primitive things which know how to handle being transformed by both a normal transformation and a "frozen" transformation. The default implementation simply applies both. At the moment, ScaleInv is the only type with a non-default instance of IsPrim.

The null primitive, which every backend can render by doing nothing.

The fundamental diagram type is represented by trees of primitives with various monoidal annotations. The Q in QDiagram stands for "Queriable", as distinguished from Diagram, a synonym for QDiagram with the query type specialized to Any.

The default sort of diagram is one where querying at a point simply tells you whether the diagram contains that point or not. Transforming a default diagram into one with a more interesting query can be done via the Functor instance of QDiagram b or the value function.

Create a diagram from a single primitive, along with an envelope, trace, subdiagram map, and query function.

Create a "point diagram", which has no content, no trace, an empty query, and a point envelope.

Extract a list of primitives from a diagram, together with their associated transformations and styles.

Get the envelope of a diagram.

Get the trace of a diagram.

Get the subdiagram map (i.e. an association from names to subdiagrams) of a diagram.

Get a list of names of subdiagrams and their locations.

Get the query function associated with a diagram.

Sample a diagram's query function at a given point.

Set the query value for True points in a diagram (i.e. points "inside" the diagram); False points will be set to mempty.

Reset the query values of a diagram to True/False: any values equal to mempty are set to False; any other values are set to True.

Set all the query values of a diagram to False.

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).

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.

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.

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" a diagram by hiding all the names, so they are no longer visible to the outside.

Make a diagram into a hyperlink. Note that only some backends will honor hyperlink annotations.

By default, diagram attributes are not affected by transformations. This means, for example, that lw 0.01 circle and scale 2 (lw 0.01 circle) will be drawn with lines of the same width, and scaleY 3 circle will be an ellipse drawn with a uniform line. Once a diagram is frozen, however, transformations do affect attributes, so, for example, scale 2 (freeze (lw 0.01 circle)) will be drawn with a line twice as thick as lw 0.01 circle, and scaleY 3 (freeze circle) will be drawn with a "stretched", variable-width line.

Another way of thinking about it is that pre-freeze, we are transforming the "abstract idea" of a diagram, and the transformed version is then drawn; when doing a freeze, we produce a concrete drawing of the diagram, and it is this visual representation itself which is acted upon by subsequent transformations.

Replace the envelope of a diagram.

Replace the trace of a diagram.

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).

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.).

Turn a diagram into a subdiagram with no accumulated context.

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.

Extract the "raw" content of a subdiagram, by throwing away the context.

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".

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.

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 the three associated types, an implementation for doRender, and one of either withStyle or renderData.

A class for backends which support rendering multiple diagrams, e.g. to a multi-page pdf or something similar.

The Renderable type class connects backends to primitives which they know how to render.

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.

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 "foo.png" 200 200)
   <interactive>:8:8:
       No instance for (Renderable Diagrams.TwoD.Image.Image b0)
         arising from a use of image
       Possible fix:
         add an instance declaration for
         (Renderable Diagrams.TwoD.Image.Image b0)
       In the first argument of width, namely
         `(image "foo.png" 200 200)'
       In the expression: width (image "foo.png" 200 200)
       In an equation for it: it = width (image "foo.png" 200 200)

GHC complains that there is no instance for Renderable Image b0; what is really going on is that it does not have enough information to decide what backend to use (hence the uninstantiated 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 R2, like so:

   ghci> width (image "foo.png" 200 200 :: D R2)
   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>:4:1:
       Couldn't match type `V a0' with R2
       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 PathLike 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 R2)
   1.9999999999999998

HasLinearMap is a poor man's class constraint synonym, just to help shorten some of the ridiculously long constraint sets.

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 class as a convenient shorthand.

The Monoid' class is a synonym for things which are instances of both Semigroup and Monoid. Ideally, the Monoid class itself will eventually include a Semigroup superclass and we can get rid of this.