Library

Module

Module type

Parameter

Class

Class type

sectionYPositions = computeSectionYPositions($el), 10)" x-init="setTimeout(() => sectionYPositions = computeSectionYPositions($el), 10)">

On This Page

Legend:

Library

Module

Module type

Parameter

Class

Class type

Library

Module

Module type

Parameter

Class

Class type

Planar 3d polygons made up of an outer, and zero or more inner `Path3.t`

s. Includes basic shape creation helpers, manipulations, (including offset and basic transformations), measurement, and validation.

3-dimensional (planar) polygon

This type is kept private to force use of `make`

, which ensures that all points of the polygon are planar and performs `Poly2.validation`

by default, hopefully providing an early warning that the shape may have issues rendering in a CAD backend.

`make ?validate ?holes outer`

Create a 3d polygon from an `outer`

path (perimeter), and zero or more `holes`

(default = `[]`

). If validate is `true`

(as it is by default), all paths are checked for coplanarity, then `Poly2.validation`

is performed on a 2d projection, raising exceptions if the defined polygon is not simple (and thus, may cause problems in CGAL).

`of_paths ?validate ps`

Create a 3d polygon from a list of paths, with the outline first, followed by the inner hole paths (if any), e.g. `(outer :: holes) as ps`

. See `make`

for details.

`of_list ps`

Create a 3d polygon from a list of paths. Same as `of_paths`

with `~validate:false`

.

`to_list t`

Convert the polygon `t`

into a list with the `outer`

path as the head.

`of_seq s`

Construct a polygon from a sequence of sequences of points `s`

.

`to_seq t`

Convert the polygon `t`

to a sequence of sequences of points.

`of_array a`

Construct a polygon from an array of arrays of points `a`

.

`to_array t`

Convert the polygon `t`

to an array of arrays of points.

`add_holes ?validate ~holes t`

Add `holes`

to `t`

. If validate is `true`

(as it is by default), `Poly2.validation`

is performed, raising exceptions if the defined polygon is not simple (and thus, may cause problems in CGAL).

`of_poly2 ?plane poly`

Lift the 2d polygon `poly`

onto `plane`

(default = `Plane.xy`

).

`to_poly2 ?validate ?plane t`

Project the 3d polygon `t`

onto `plane`

(default = `Plane.xy`

). If `validate`

is `true`

, 2d polygon `Poly2.validation`

is performed (default = `true`

).

`circle ?fn ?fa ?fs ?plane r`

Create a circle of radius `r`

, on the optionally provided `plane`

(default = `Plane.xy`

).

`square ?center ?plane dims`

Create a rectangular polygon with xy `dims`

(e.g. width and height). If `center`

is `true`

then the path will be centred around the origin (default = `false`

). The polygon is drawn on the provided `plane`

(default = `Plane.xy`

).

`ellipse ?fn ?fa ?fs ?plane radii`

Draw an ellipse with xy `radii`

onto `plane`

(default = `Plane.xy`

). The greater of the two radii is used for fragment/resolution calculation.

`star ?plane ~r1 ~r2 n`

Draw an `n`

pointed star with inner radius `r1`

and outer radius `r2`

onto `plane`

(default = `Plane.xy`

).

`ring ?fn ?fa ?fs ?plane ~thickness radii`

Draw an empty elliptical ring of outer xy `radii`

, with the given radial `thickness`

(difference between outer and inner radii) on the provided `plane`

(default = `Plane.xy`

). For a circular ring, use equal x and y radii.

`box ?center ?plane ~thickness dims`

Create a rectangular empty box of outer xy dimensions `dims`

, with the given xy `thickness`

(difference between outer and inner xy dimensions). If `center`

is `true`

, then the path will be centred around the origin (default = `false`

). The polygon is drawn on the provided `plane`

(default = `Plane.xy`

).

`centroid ?eps t`

Compute the centroid of the outer path of the polygon `t`

. If `t.outer`

is collinear or self-intersecting (within `eps`

tolerance), an `Invalid_argument`

exception is raised.

`val area : ?signed:bool -> t -> float`

`area ?signed t`

Compute the total area of the polygon `t`

. If `signed`

is `true`

, then the signed areas of the `outer`

and `holes`

paths of `t`

will be summed (keep in mind that this is dependent on winding direction, which should generally be opposite between outer and inner paths), otherwise the unsigned (positive) area of the `holes`

will be subtracted (default = `false`

).

```
val offset :
?fn:int ->
?fs:float ->
?fa:float ->
?check_valid:[ `Quality of int | `No ] ->
?mode:[< `Chamfer | `Delta | `Radius Delta ] ->
float ->
t ->
t
```

`offset ?fn ?fs ?fa ?check_valid ?mode d t`

Offset outer and inner paths of `t`

by the specified distance `d`

. The `mode`

governs how `d`

is used to create the new corners.

``Delta`

will create a new outline whose sides are a fixed distance`d`

(+ve out, -ve in) from the original outline (this is the default behaviour).``Chamfer`

fixed distance offset by`d`

as with delta, but with corners chamfered.``Radius`

creates a new outline as if a circle of some radius`d`

is rotated around the exterior (`d > 0`

) or interior (`d < 0`

) original outline.`fn`

,`fs`

, and`fa`

parameters govern the number of points that will be used for these arcs (they are ignored for delta and chamfer modes).- The
`check_valid`

default of``Quality 1`

will check the validity of shifted line segments by checking whether their ends and`n`

additional points spaced throughout are far enough from the original path. If there are no points that have been offset by the target`d`

, a`Failure`

exception will be raised. Checking can be turned off by setting this to``No`

.

`map f t`

Map the outer and inner paths of `t`

with the function `f`

.

`val quaternion : ?about:V3.t -> Quaternion.t -> t -> t`

On This Page