Copyright | (c) 2013 diagrams-lib team (see LICENSE) |
---|---|

License | BSD-style (see LICENSE) |

Maintainer | diagrams-discuss@googlegroups.com |

Safe Haskell | None |

Language | Haskell2010 |

"Traces", aka embedded raytracers, for finding points on the edge of a diagram. See Diagrams.Core.Trace for internal implementation details.

- data Trace (v :: * -> *) n :: (* -> *) -> * -> *
- class (Additive (V a), Ord (N a)) => Traced a
- trace :: (Metric v, OrderedField n, Semigroup m) => Lens' (QDiagram b v n m) (Trace v n)
- setTrace :: (OrderedField n, Metric v, Semigroup m) => Trace v n -> QDiagram b v n m -> QDiagram b v n m
- withTrace :: (InSpace v n a, Metric v, OrderedField n, Monoid' m, Traced a) => a -> QDiagram b v n m -> QDiagram b v n m
- 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)
- boundaryFrom :: (OrderedField n, Metric v, Semigroup m) => Subdiagram b v n m -> v n -> Point v n
- boundaryFromMay :: (Metric v, OrderedField n, Semigroup m) => Subdiagram b v n m -> v n -> Maybe (Point v n)

# Types

data Trace (v :: * -> *) n :: (* -> *) -> * -> * #

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

.

Show (Trace v n) | |

Ord n => Semigroup (Trace v n) | Traces form a semigroup with pointwise minimum as composition.
Hence, if |

Ord n => Monoid (Trace v n) | |

(Additive v, Ord n) => Traced (Trace v n) | |

(Additive v, Num n) => Transformable (Trace v n) | |

(Additive v, Num n) => HasOrigin (Trace v n) | |

Wrapped (Trace v n) | |

(Metric v, OrderedField n) => Alignable (Trace v n) Source # | |

Rewrapped (Trace v n) (Trace v' n') | |

type V (Trace v n) | |

type N (Trace v n) | |

type Unwrapped (Trace v n) | |

class (Additive (V a), Ord (N a)) => Traced a #

`Traced`

abstracts over things which have a trace.

Traced b => Traced [b] | |

Traced b => Traced (Set b) | |

Traced t => Traced (TransInv t) | |

(RealFloat n, Ord n) => Traced (CSG n) # | |

(RealFloat n, Ord n) => Traced (Frustum n) # | |

(Fractional n, Ord n) => Traced (Box n) # | |

OrderedField n => Traced (Ellipsoid n) # | |

(Traced a, Num (N a)) => Traced (Located a) # | The trace of a |

(Traced a, Traced b, SameSpace a b) => Traced (a, b) | |

Traced b => Traced (Map k b) | |

(Additive v, Ord n) => Traced (Trace v n) | |

(Additive v, Ord n) => Traced (Point v n) | The trace of a single point is the empty trace, |

TypeableFloat n => Traced (BoundingBox V3 n) # | |

RealFloat n => Traced (BoundingBox V2 n) # | |

(Metric v, OrderedField n, Semigroup m) => Traced (QDiagram b v n m) | |

(OrderedField n, Metric v, Semigroup m) => Traced (Subdiagram b v n m) | |

# Diagram traces

setTrace :: (OrderedField n, Metric v, Semigroup m) => Trace v n -> QDiagram b v n m -> QDiagram b v n m #

Replace the trace of a diagram.

withTrace :: (InSpace v n a, Metric v, OrderedField n, Monoid' m, Traced a) => a -> QDiagram b v n m -> QDiagram b v n m Source #

Use the trace from some object as the trace for a diagram, in place of the diagram's default trace.

# Querying traces

traceV :: ((~) * n (N a), Num n, Traced a) => Point (V a) n -> V a n -> a -> Maybe (V a n) #

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

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

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

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

# Subdiagram traces

boundaryFrom :: (OrderedField n, Metric v, Semigroup m) => Subdiagram b v n m -> v n -> Point v n Source #

Compute the furthest point on the boundary of a subdiagram,
beginning from the location (local origin) of the subdiagram and
moving in the direction of the given vector. If there is no such
point, the origin is returned; see also `boundaryFromMay`

.

boundaryFromMay :: (Metric v, OrderedField n, Semigroup m) => Subdiagram b v n m -> v n -> Maybe (Point v n) Source #

Compute the furthest point on the boundary of a subdiagram,
beginning from the location (local origin) of the subdiagram and
moving in the direction of the given vector, or `Nothing`

if
there is no such point.