Index

API symbols

`$`:

• bezier: `$`(curve: Bezier | DynBezier): string

`[]`:

• bezier: `[]`[N](curve: Bezier[N]; point: range[0 .. N]): Vec2
• bezier: `[]`(curve: DynBezier; point: Natural): Vec2

align:

• bezier: align(curve: Bezier | DynBezier; p1, p2: Vec2): auto

approxLen:

• bezier: approxLen(curve: Bezier | DynBezier; steps: Positive): float
• bezier: approxLen[T](lut: LUT[T]): float

Bezier:

• bezier: Bezier

boundingBox:

• bezier: boundingBox(curve: Bezier | DynBezier): tuple[minX, minY, maxX, maxY: float]

compute:

• bezier: compute[N](curve: Bezier[N]; t: float): Vec2
• bezier: compute(curve: DynBezier; t: float): Vec2

DeCasteljau:

• util: DeCasteljau

deCasteljau:

• util: deCasteljau(points: openArray[Vec2]; t: float): DeCasteljau

derivative:

• bezier: derivative[N](curve: Bezier[N]): auto
• bezier: derivative(curve: DynBezier): DynBezier

DynBezier:

• bezier: DynBezier

extrema:

• bezier: extrema[N](curve: Bezier[N]): float
• bezier: extrema(curve: DynBezier): float

finalPoint:

• util: finalPoint(calculated: DeCasteljau): Vec2

findMaxY:

• bezier: findMaxY(curve: Bezier | DynBezier; x: float): Option[Vec2]

findMinY:

• bezier: findMinY(curve: Bezier | DynBezier; x: float): Option[Vec2]

findY:

• bezier: findY(curve: Bezier | DynBezier; x: float): Vec2

forDistinct:

• util: forDistinct[T](input: seq[T]): T

forIndexed:

• util: forIndexed(i, value, iter, exec: untyped)

intersects:

• bezier: intersects(curve: Bezier | DynBezier; p1, p2: Vec2): Vec2

intervals:

• bezier: intervals[T](lut: LUT[T]; steps: Positive): Vec2

isOnLine:

• util: isOnLine(point, p1, p2: Vec2): bool

items:

• bezier: items(curve: DynBezier | Bezier): lent Vec2

left:

• util: left(calculated: DeCasteljau): Vec2

length:

• bezier: length(curve: Bezier | DynBezier): float

linesIntersect:

• util: linesIntersect(p1, p2, p3, p4: Vec2): Option[Vec2]

LUT:

• bezier: LUT

lut:

• bezier: lut[T: Bezier | DynBezier](curve: T; steps: range[2 .. high(int)]): LUT[T]

mapIt:

• bezier: mapIt[N](curve: Bezier[N]; mapper: untyped): Bezier[N]
• bezier: mapIt(curve: DynBezier; mapper: untyped): DynBezier

newBezier:

• bezier: newBezier[N](points: varargs[Vec2]): Bezier[N]

newDynBezier:

• bezier: newDynBezier(points: varargs[Vec2]): DynBezier

normal:

• bezier: normal(curve: Bezier | DynBezier; t: float): Vec2

order:

• bezier: order[N](curve: Bezier[N]): Natural
• bezier: order(curve: DynBezier): Natural

pairs:

• bezier: pairs(curve: DynBezier | Bezier): (int, Vec2)

points:

• bezier: points(curve: Bezier | DynBezier; steps: range[2 .. high(int)]): tuple[t: float, point: Vec2]

project:

• bezier: project[T](lut: LUT[T]; point: Vec2): float

right:

• util: right(calculated: DeCasteljau): Vec2

roots:

• util: roots[N: static[int]](entries: array[N, float]): float
• util: roots(entries: seq[float]): float

segments:

• bezier: segments(curve: Bezier | DynBezier; steps: Positive): (Vec2, Vec2)

split:

• bezier: split[N](curve: Bezier[N]; t: float): (Bezier[N], Bezier[N])
• bezier: split(curve: DynBezier; t: float): (DynBezier, DynBezier)

tangent:

• bezier: tangent(curve: Bezier | DynBezier; t: float): Vec2

tightBoundingBox:

• bezier: tightBoundingBox(curve: Bezier | DynBezier): array[4, Vec2]

xs:

• bezier: xs[N](curve: Bezier[N]): array[N + 1, float]
• bezier: xs(curve: DynBezier): seq[float]

yieldAll:

• util: yieldAll(iter: untyped)

ys:

• bezier: ys[N](curve: Bezier[N]): array[N + 1, float]
• bezier: ys(curve: DynBezier): seq[float]