module MetaPath:MetaPaths: gradually build a path with constraints, get a real path at thxe end.`sig`

..`end`

MetaPaths are the objects used to describe lines, curves, and more generally almost everything that is drawn with Mlpost. A path (

`Path.t`

) is defined by points and control points.
A metapath is defined by points (knots) and constraints on the links
between the points. A metapath is an easy way to define a path gradually
with only a few points, and apply heuristics afterwards to transform it
into a real path (using `of_metapath`

).type`direction =`

`Path.direction`

A

`direction`

is used to put constraints on metapaths:
`vec p`

defines a direction by a point (interpreted as a vector)`curl f`

changes the curling factor of the extremity of a metapath; higher curling factor means flatter curves`noDir`

means no particular direction

`val vec : ``Point.t -> direction`

`val curl : ``float -> direction`

`val noDir : ``direction`

type`knot =`

`Path.knot`

A

`knot`

is the basic element of a metapath, and is simply a point
with an incoming and outgoing direction constraint`val knotp : ``?l:direction ->`

?r:direction -> Point.t -> knot

Build a knot from a point; the optional arguments are the
incoming directions

`val knotlist : ``(direction * Point.t * direction) list ->`

knot list

type`joint =`

`Path.joint`

A joint is the connection between two knots in a metapath. It is either

`jLine`

for a straight line`jCurve`

for a spline curve`jCurveNoInflex`

to avoid inflexion points`jTension f1 f2`

to specify "tension" on the joint;`jCurve`

uses a default tension of 1. Higher tension means less "wild" curves`jControls p1 p2`

to explicitely specify control points

`val jLine : ``joint`

`val jCurve : ``joint`

`val jCurveNoInflex : ``joint`

`val jTension : ``float -> float -> joint`

`val jControls : ``Point.t -> Point.t -> joint`

`type `

t

The abstract type of metapaths

type`path =`

`Path.t`

In all the functions below :

- noDir is the default direction
- jCurve is the default joint

`val knot : ``?l:direction ->`

?r:direction ->

?scale:(float -> Num.t) -> float * float -> knot

Build a knot from a pair of floats

`l`

: an incoming direction`r`

: an outgoing direction`scale`

: a scaling factor applied to the floats`val knotn : ``?l:direction ->`

?r:direction ->

Num.t * Num.t -> knot

Build a knot from a Num.t pair; the optional arguments are as in

`MetaPath.knot`

`val path : ``?style:joint ->`

?scale:(float -> Num.t) -> (float * float) list -> t

Build a metapath from a list of pairs of floats

`style`

: the joint style used for all joints in the metapath`scale`

: permits to scale the whole metapath`val pathn : ``?style:joint ->`

(Num.t * Num.t) list -> t

Same as

`metapath`

, but uses a `Num.t`

list`val pathk : ``?style:joint ->`

knot list -> t

Same as

`metapath`

, but uses a knot list`val pathp : ``?style:joint -> Point.t list -> t`

Same as

`metapath`

but uses a point list`val jointpathk : ``knot list -> joint list -> t`

Build a metapath from

`n`

knots and `n-1`

joints`val jointpathp : ``Point.t list -> joint list -> t`

Build a metapath from

`n`

points and `n-1`

joints,
with default directions`val jointpathn : ``(Num.t * Num.t) list ->`

joint list -> t

`val jointpath : ``?scale:(float -> Num.t) ->`

(float * float) list -> joint list -> t

Build a metapath from

`n`

float_pairs and `n-1`

joints,
with default directions`val cycle : ``?dir:direction ->`

?style:joint -> t -> path

Close a metapath using direction

`dir`

and style `style`

`val concat : ``?style:joint ->`

t -> knot -> t

Add a knot at the end of a metapath

`val start : ``knot -> t`

Create a simple metapath with one knot

`val append : ``?style:joint ->`

t -> t -> t

Append a metapath to another using joint

`style`

`val defaultjoint : ``joint`

The default joint style (

`JCurve`

)`val to_path : ``t -> path`

Compute the control point of the path
for a good looking result according to the constraint
on the direction, tension, curve

`val of_path : ``path -> t`

Obtain a metapath from a path with exactly the same
control point. p = of_metapath (of_path p) is true but
not the opposite.