`Vg.P`

Paths.

Consult their semantics.

The `|>`

operator is used to build paths from the empty path. For this reason path combinators always take the path to use as the last argument.

The type for path caps. Semantics.

The type for segment jointures. Semantics.

The type for dashes. Semantics.

`type outline = {`

`width : float;`

(*Outline width.

*)`cap : cap;`

(*Shape at the end points of open subpaths and dashes.

*)`join : join;`

(*Shape at segment jointures.

*)`miter_angle : float;`

(*Limit

*)*angle*for miter joins (in [0;pi]).`dashes : dashes option;`

(*Outline dashes.

*)

`}`

The type for path outline area specifications. Semantics.

`val o : outline`

`o`

holds a default set of values. `width`

is `1.`

, `cap`

is ``Butt`

, `join`

is ``Miter`

, `miter_angle`

is `11.5`

degrees in radians and `dashes`

is `None`

.

`val pp_outline : Stdlib.Format.formatter -> outline -> unit`

`pp_outline ppf o`

prints a textual representation of `o`

on `ppf`

.

`val pp_area : Stdlib.Format.formatter -> area -> unit`

`pp_area ppf a`

prints a textual representation of `a`

on `ppf`

`type t = path`

The type for paths.

`val empty : path`

`empty`

is the empty path.

If a path segment is directly added to a path `p`

which is `empty`

or whose last subpath is closed, a new subpath is *automatically* started with `sub`

` P2.o p`

.

In the functions below the default value of the optional argument `rel`

is `false`

. If `true`

, the points given to the function are expressed *relative* to the last point of the path or `Gg.P2.o`

if the path is `empty`

.

`sub pt p`

is `p`

with a new subpath starting at `pt`

. If `p`

's last subpath had no segment it is automatically `close`

d.

`line pt p`

is `p`

with a straight line from `p`

's last point to `pt`

.

`qcurve c pt p`

is `p`

with a quadratic bézier curve from `p`

's last point to `pt`

with control point `c`

.

`ccurve c c' pt p`

is `p`

with a cubic bézier curve from `p`

's last point to `pt`

with control points `c`

and `c'`

.

```
val earc :
?rel:bool ->
?large:bool ->
?cw:bool ->
?angle:float ->
Gg.size2 ->
Gg.p2 ->
path ->
path
```

`earc large cw a r pt p`

is `p`

with an elliptical arc from `p`

's last point to `pt`

. The ellipse is defined by the horizontal and vertical radii `r`

which are rotated by `a`

with respect to the current coordinate system. If the parameters do not define a valid ellipse (points coincident or too far apart, zero radius) the arc collapses to a line.

In general the parameters define four possible arcs, thus `large`

indicates if more than pi radians of the arc is to be traversed and `cw`

if the arc is to be traversed in the clockwise direction (both default to `false`

). In the following image, in red, the elliptical arc from the left point to the right one. The top row is `~large:false`

and the left column is `~cw:false`

:

`close p`

is `p`

with a straight line from `p`

's last point to `p`

's current subpath starting point, this ends the subpath.

The following convenience functions start and close a new subpath to the given path.

`circle c r p`

is `p`

with a circle subpath of center `c`

and radius `r`

.

`ellipse c r p`

is `p`

with an axis-aligned (unless `angle`

is specified) ellipse subpath of center `c`

and radii `r`

.

`rect r p`

is `p`

with an axis-aligned rectangle subpath `r`

. If `r`

is empty, `p`

is returned.

`rrect r cr p`

is `p`

with an axis-aligned rectangle subpath `r`

with round corners of radii `cr`

. If `r`

is empty, `p`

is returned.

`smooth_qcurve pt p`

is `qcurve c pt p`

with control point `c`

defined as the reflexion of the control point of the previous quadratic curve relative to the last point of `p`

. If the previous segment of `p`

is not a quadratic curve, `c`

is the last point of `p`

or the origin if the path is empty.

`smooth_ccurve c' pt p`

is `ccurve c c' pt p`

with control point `c`

defined as the reflexion of the second control point of the previous cubic curve relative to the last point of `p`

. If the previous segment of `p`

is not a cubic curve, `c`

is the last point of `p`

or the origin if the path is empty.

`val last_pt : path -> Gg.p2`

`last_pt p`

is the last point of `p`

's last subpath. Raises `Invalid_argument`

if `p`

is `empty`

.

`append p' p`

appends `p'`

to `p`

. If `p`

's last subpath had no segment it is closed.

**Warning.** To accomodate `|>`

the argument order is the opposite of `List.append`

.

`tr m p`

is the affine transform in homogenous 2D space of the path `p`

by `m`

.

**Bug.** Elliptical arcs transformation is currently broken if `m`

doesn't scale uniformely or shears.

`type fold = [ `

`| `Sub of Gg.p2`

(*New subpath starting at point, the point

*)`| `Line of Gg.p2`

(*Line to point, the point

*)`| `Qcurve of Gg.p2 * Gg.p2`

(*Quadratic curve to point, a control point and the point

*)`| `Ccurve of Gg.p2 * Gg.p2 * Gg.p2`

(*Cubic curve to point, two control points and the point

*)`| `Earc of bool * bool * float * Gg.size2 * Gg.p2`

(*Elliptic arc to point,

*)`large`

,`cw`

,`angle`

,`raddii`

and the point`| `Close`

(*Line to point of the last

*)``Sub`

, ends the subpath.

` ]`

The type for path folds.

`fold ~rev f acc p`

, applies `f`

to each subpath and subpath segments with an accumulator. Subpaths are traversed in the order they were specified, always start with a ``Sub`

, but may not be ``Close`

d. If `rev`

is `true`

(defaults to `false`

) the segments and subpaths are traversed in reverse order.

`val is_empty : path -> bool`

`is_empty p`

is `true`

iff `p`

is `empty`

.

`equal_f eq p p'`

is like `equal`

but uses `eq`

to test floating point values.

`compare_f cmp p p'`

is like `compare`

but uses `cmp`

to compare floating point values.

`val pp : Stdlib.Format.formatter -> path -> unit`

`pp ppf p`

prints a textual representation of `p`

on `ppf`

.

```
val pp_f :
(Stdlib.Format.formatter -> float -> unit) ->
Stdlib.Format.formatter ->
path ->
unit
```

`pp_f pp_float ppf p`

prints `p`

like `pp`

but uses `pp_float`

to print floating point values.

`val to_string : path -> string`