Maintainer | diagrams-discuss@googlegroups.com |
---|---|

Safe Haskell | Safe-Infered |

Types which have an intrinsic notion of a "local origin",
*i.e.* things which are *not* invariant under translation.

# Documentation

class VectorSpace (V t) => HasOrigin t whereSource

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, `Trail`

s) are
transformable but are translationally invariant, i.e. have no
origin.

moveOriginTo :: Point (V t) -> t -> tSource

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.

HasOrigin a => HasOrigin [a] | |

(HasOrigin a, Ord a) => HasOrigin (Set a) | |

VectorSpace v => HasOrigin (Point v) | |

VectorSpace (V t) => HasOrigin (TransInv t) | |

HasLinearMap v => HasOrigin (Transformation v) | |

VectorSpace v => HasOrigin (LocatedEnvelope v) | |

(InnerSpace v, AdditiveGroup (Scalar v), Fractional (Scalar v)) => HasOrigin (Envelope v) | The local origin of an envelope is the point with respect to
which bounding queries are made, |

(AdditiveGroup (Scalar v), Fractional (Scalar v), InnerSpace v) => HasOrigin (NameMap v) | |

(HasOrigin a, HasOrigin b, ~ * (V a) (V b)) => HasOrigin (a, b) | |

HasOrigin a => HasOrigin (Map k a) | |

VectorSpace v => HasOrigin (Query v m) | |

(HasLinearMap v, InnerSpace v, OrderedField (Scalar v), Monoid' m) => HasOrigin (QDiagram b v m) | Every diagram has an intrinsic "local origin" which is the basis for all combining operations. |

moveOriginBy :: HasOrigin t => V t -> t -> tSource

Move the local origin by a relative vector.

moveTo :: HasOrigin t => Point (V t) -> t -> tSource

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