Module Mlpost.MetaPath

MetaPaths: gradually build a path with constraints, get a real path at thxe end.

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.Warning they are going in the same direction.

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

Labelled metapath constructors

val knot : ?⁠l:direction -> ?⁠r:direction -> ?⁠scale:(float -> Num.t) -> (float * float) -> knot

Build a knot from a pair of floats

parameter l

an incoming direction

parameter r

an outgoing direction

parameter 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 knot

val path : ?⁠style:joint -> ?⁠scale:(float -> Num.t) -> (float * float) list -> t

Build a metapath from a list of pairs of floats

parameter style

the joint style used for all joints in the metapath

parameter cycle

if given, the metapath is closed using the given style

parameter 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

Primitive metapath constructors

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

Predefined values

val defaultjoint : joint

The default joint style (JCurve)

Conversions

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.