korge-foundation/korlibs.math.geom.bezier/Bezier

Bezier

class Bezier : Curve, IsAlmostEquals<Bezier>

Port of the operations of the library Bezier.JS with some adjustments, Original library created by Pomax: https://github.com/Pomax/bezierjs Based on algorithms described here: https://pomax.github.io/bezierinfo/

Constructors

Bezier

constructor()

constructor(p0: Point, p1: Point)

constructor(p0: Point, p1: Point, p2: Point)

constructor(p0: Point, p1: Point, p2: Point, p3: Point)

constructor(points: PointList)

Types

Companion

object Companion

Curvature

data class Curvature(val k: Double = 0.0, val r: Double = 0.0, val dk: Double = 0.0, val adk: Double = 0.0)

Extrema

class Extrema(val xt: DoubleArray, val yt: DoubleArray)

ProjectedPoint

data class ProjectedPoint(var p: Point = Point(), var t: Ratio = Ratio.ZERO, var dSq: Double = 0.0) : IsAlmostEquals<Bezier.ProjectedPoint>

Properties

boundingBox

val boundingBox: Rectangle

clockwise

val clockwise: Boolean

dims

val dims: Int

direction

val direction: Angle

dpoints

val dpoints: List<PointList>

extrema

val extrema: Bezier.Extrema

isLinear

val isLinear: Boolean

isSimple

val isSimple: Boolean

Determines if this Bezier is simple.

length

open override val length: Double

Calculates the length of this curve .

lut

val lut: CurveLUT

order

open override val order: Int

outerCircle

val outerCircle: Circle

points

val points: PointList

Functions

calc

open override fun calc(t: Ratio): Point

calcOffset

open fun calcOffset(t: Ratio, offset: Double): Point

clone

fun ~~clone~~(): Bezier

compute

fun compute(t: Ratio): Point

Computes the point of the curve at t

curvature

fun curvature(t: Ratio, kOnly: Boolean = false): Bezier.Curvature

derivative

fun derivative(t: Ratio, normalize: Boolean = false): Point

The derivate vector of the curve at t (normalized when normalize is set to true)

equals

open operator override fun equals(other: Any?): Boolean

get

operator fun get(t: Ratio): Point

Computes the point of the curve at t

getBounds

open override fun getBounds(): Rectangle

fun getBounds(m: Matrix): Rectangle

getEquidistantPoints

fun Curve.getEquidistantPoints(count: Int = this.recommendedDivisions(), out: PointArrayList = PointArrayList()): PointList

getLUT

fun getLUT(steps: Int = 100, out: CurveLUT = CurveLUT(this, steps + 1)): CurveLUT

getPoints

fun Curve.getPoints(count: Int = this.recommendedDivisions(), out: PointArrayList = PointArrayList()): PointList

hashCode

open override fun hashCode(): Int

hull

fun hull(t: Ratio, out: PointArrayList = PointArrayList()): PointList

hullOrNull

fun hullOrNull(t: Ratio, out: PointArrayList = PointArrayList()): PointList?

inflections

fun inflections(): DoubleArray

Returns the t values where the curve changes its sign

intersections

fun intersections(line: Line): DoubleArray

fun intersections(curve: Bezier, threshold: Double = 0.5): List<Pair<Ratio, Ratio>>

isAlmostEquals

open override fun isAlmostEquals(other: Bezier, epsilon: Double): Boolean

normal

open override fun normal(t: Ratio): Point

fun normal(t: Ratio, normalize: Boolean = true): Point

The normal vector of the curve at t (normalized when normalize is set to true)

offset

fun offset(d: Double): List<Bezier>

This function creates a new curve, offset along the curve normals, at distance d. Note that deep magic lies here and the offset curve of a Bézier curve cannot ever be another Bézier curve.

fun offset(t: Ratio, d: Double): Point

A coordinate is returned, representing the point on the curve at t=..., offset along its normal by a distance d

outline