#### vg

## Path areas

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 |

`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 : Format.formatter -> outline -> unit`

`pp_outline ppf o`

prints a textual representation of `o`

on `ppf`

.

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

`pp_area ppf a`

prints a textual representation of `a`

on `ppf`

## Paths

`type t = path`

The type for paths.

`val empty : path`

`empty`

is the empty path.

## Subpaths and segments

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.

### Derived subpaths

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.

## Functions

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

## Traversal

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

`| ` ``Close` | (* Line to point of the last |

` ]`

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.

## Predicates and comparisons

`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 p p'`

is `Stdlib.compare`

` p p'`

.

`compare_f cmp p p'`

is like `compare`

but uses `cmp`

to compare floating point values.

## Printers

`val to_string : path -> string`

`to_string p`

is a textual representation of `p`

.

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

`pp ppf p`

prints a textual representation of `p`

on `ppf`

.

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

`pp_f pp_float ppf p`

prints `p`

like `pp`

but uses `pp_float`

to print floating point values.