Index

Modules: clip, delaunator, helpers, orient2d.

API symbols

boundHeight:

• delaunator: boundHeight[T](d: Delaunator[T]): T

boundWidth:

• delaunator: boundWidth[T](d: Delaunator[T]): T

circumcenter:

• delaunator: circumcenter[F](ax, ay, bx, by, cx, cy: F): tuple[x, y: F]

clipInfinite:

• clip: clipInfinite[T](polygon: InfConvexPoly[T]; xMin, yMin, xMax, yMax: T): seq[ array[2, T]]

Delaunator:

• delaunator: Delaunator

edgeIdsAroundPoint:

• helpers: edgeIdsAroundPoint(d: Delaunator; eid: int32): seq[int32]

extentHeight:

• delaunator: extentHeight[T](d: Delaunator[T]): T

extentWidth:

• delaunator: extentWidth[T](d: Delaunator[T]): T

fromCoords:

• delaunator: fromCoords[T](coordinates: var seq[T]): Delaunator[T]

fromCustom:

• delaunator: fromCustom[P, T](points: seq[P]; getX, getY: proc (p: P): T): Delaunator[T]

fromPoints:

• delaunator: fromPoints[P, T](points: seq[P]): Delaunator[T]

grid:

• helpers: grid[F](n, m: int; fromN, toN, fromM, toM: F; leftEdge, rightEdge, topEdge, bottomEdge: bool = true; jitterN, jitterM: F = 0.0; pinHull: bool = false; r: var Rand = randState()): seq[F]

halfedgeIdsOfTriangle:

• helpers: halfedgeIdsOfTriangle(tid: uint32): array[3, int32]

hullNext:

• delaunator: hullNext(d: Delaunator; sid: uint32): uint32

hullPrev:

• delaunator: hullPrev(d: Delaunator; sid: uint32): uint32

InfConvexPoly:

• clip: InfConvexPoly

iterHullEdges:

• helpers: iterHullEdges[T](d: Delaunator[T]): tuple[hid: uint32, eid: int32, pid, qid: uint32, p, q: array[2, T]]

iterHullPoints:

• helpers: iterHullPoints[T](d: Delaunator[T]): tuple[hid: uint32, pid: uint32, p: array[2, T]]

iterPoints:

• helpers: iterPoints[T](d: Delaunator[T]): tuple[pid: uint32, p: array[2, T]]

iterTriangleEdges:

• helpers: iterTriangleEdges[T](d: Delaunator[T]): tuple[tid: uint32, eid: int32, pid, qid: uint32, p, q: array[2, T]]

iterTriangles:

• helpers: iterTriangles[T](d: Delaunator[T]): tuple[tid: uint32, pid, qid, rid: uint32, p, q, r: array[2, T]]

iterVoronoiEdges:

• helpers: iterVoronoiEdges[T](d: Delaunator[T]): tuple[eid: int32, p, q: array[2, T]]

iterVoronoiRegions:

• helpers: iterVoronoiRegions[T](d: Delaunator[T]): tuple[pid: uint32, verts: seq[array[2, T]]]

nextHalfedge:

• helpers: nextHalfedge(eid: int32): int32

normalDist:

• helpers: normalDist[F](count: int; mu = 0.0; sigma = 1.0; r: var Rand = randState()): seq[ F]

orient2d:

• orient2d: orient2d(ax, ay, bx, by, cx, cy: SomeFloat): SomeFloat

pointIdsOfTriangle:

• helpers: pointIdsOfTriangle(d: Delaunator; tid: uint32): seq[uint32]

polygonCentroid:

• helpers: polygonCentroid[T](polygon: seq[array[2, T]]): array[2, T]

prevHalfedge:

• helpers: prevHalfedge(eid: int32): int32

project:

• clip: project[T](p, v: array[2, T]; xMin, yMin, xMax, yMax: T): Option[array[2, T]]

siteToLeftmostHalfedge:

• delaunator: siteToLeftmostHalfedge(d: Delaunator; sid: uint32): int32

triangleCentroid:

• helpers: triangleCentroid[T](d: Delaunator[T]; tid: uint32): array[2, T]

triangleCircumcenter:

• helpers: triangleCircumcenter[T](d: Delaunator[T]; tid: uint32): array[2, T]

triangleIdOfEdge:

• helpers: triangleIdOfEdge(eid: int32): uint32

triangleIdsAdjacentToTriangle:

• helpers: triangleIdsAdjacentToTriangle(d: Delaunator; tid: uint32): seq[uint32]

uniformDist:

• helpers: uniformDist[F](count: int; a: F; b: F; r: var Rand = randState()): seq[F]

update:

• delaunator: update[T](this: var Delaunator)

voronoiRegion:

• helpers: voronoiRegion[T](d: Delaunator[T]; pid: uint32): tuple[pid: uint32, verts: seq[array[2, T]]]

zipDists:

• helpers: zipDists[F](s1, s2: openArray[F]): seq[F]

zipPolarDists:

• helpers: zipPolarDists[F](r, t: openArray[F]; xOffset, yOffset: F = F(0.0)): seq[F]