Path (mlpost.Mlpost.Path)

type direction

A direction is used to put constraints on paths:

vec p defines a direction by a point (interpreted as a vector)
curl f changes the curling factor of the extremity of a path; 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

A knot is the basic element of a path, 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

A joint is the connection between two knots in a path. 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 paths

In all the functions below :

noDir is the default direction
jCurve is the default joint

Labelled path 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 ->
  ?cycle:joint ->
  ?scale:(float -> Num.t) ->
  (float * float) list ->
  t

Build a path from a list of pairs of floats

parameter style
the joint style used for all joints in the path

parameter cycle
if given, the path is closed using the given style

parameter scale
permits to scale the whole path

val pathn : ?style:joint -> ?cycle:joint -> (Num.t * Num.t) list -> t

Same as path, but uses a Num.t list

val pathk : ?style:joint -> ?cycle:joint -> knot list -> t

Same as path, but uses a knot list

val pathp : ?style:joint -> ?cycle:joint -> Point.t list -> t

Same as path but uses a point list

val jointpathk : knot list -> joint list -> t

Build a path from n knots and n-1 joints

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

Build a path 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 path from n float_pairs and n-1 joints, with default directions

val cycle : ?dir:direction -> ?style:joint -> t -> t

Close a path using direction dir and style style

Primitive path constructors

val concat : ?style:joint -> t -> knot -> t

Add a knot at the end of a path

val start : knot -> t

Create a simple path with one knot

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

Append a path to another using joint style

More complex constructions on paths

val length : t -> Num.t

Number of nodes in a path, minus one.

val point : float -> t -> Point.t

point f p returns a certain point on the path p; f is given "in control points": 0. means the first control point, 1. the second and so on; intermediate values are accepted.

val pointn : Num.t -> t -> Point.t

Same as point but for a Num.t.

val direction : float -> t -> Point.t

direction f p returns the direction of the tangent at point f p.

val directionn : Num.t -> t -> Point.t

Same as direction but for a Num.t.

val subpath : float -> float -> t -> t

subpath start end path selects the subpath of path that lies between start and end. start and end are given in control points, as in point.

val subpathn : Num.t -> Num.t -> t -> t

Same as subpathn but using Num.t.

val transform : Transform.t -> t -> t

Apply a transformation to a path

val scale : Num.t -> t -> t

val rotate : float -> t -> t

val shift : Point.t -> t -> t

val yscale : Num.t -> t -> t

val xscale : Num.t -> t -> t

Shortcuts for transformations of Paths

val cut_after : t -> t -> t

cut_after p1 p2 cuts p2 after the intersection with p1. To memorize the order of the arguments, you can read: "cut after p1"

val cut_before : t -> t -> t

Same as cut_after, but cuts before

val strip : Num.t -> t -> t

strip n p removes two segments of length n at each end of path p

val build_cycle : t list -> t

Build a cycle from a set of intersecting paths

Predefined values

val defaultjoint : joint

The default joint style (JCurve)

val fullcircle : t

A full circle of radius 1 and centered on the origin

val halfcircle : t

The upper half of fullcircle

val quartercircle : t

The right half of halfcircle

val unitsquare : t

A full square of size 1 and centered on the origin

Conversions

type metapath = MetaPath.t

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

val of_metapath : metapath -> t

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

val to_metapath : t -> metapath

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

Smart path

type orientation =

| Up
| Down
| Left
| Right
| Upn of Num.t
| Downn of Num.t
| Leftn of Num.t
| Rightn of Num.t

val smart_path : ?style:joint -> orientation list -> Point.t -> Point.t -> t

val draw : 
  ?brush:Brush.t ->
  ?color:Color.t ->
  ?pen:Pen.t ->
  ?dashed:Dash.t ->
  t ->
  Command.t

Draw a path

parameter brush
the brush used to draw the path; the next argument redefined this one

parameter color
the color of the path; default is black

parameter pen
the pen used to draw the path; default is Brush.Pen.default

parameter dashed
if given, the path is drawn using that dash_style.

val fill : ?color:Color.t -> t -> Command.t

Fill a contour given by a closed path

parameter color
the color used to fill the area; default is black